From 90ffe3a6e0b93ad81ff6e8fe7d447db1846c3633 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 13:16:08 +0000
Subject: [PATCH 1/9] Add GitHub Copilot agent support to config and
 installation script

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 commands/github-copilot/discover-standards.md | 215 +++++++++++++
 commands/github-copilot/index-standards.md    | 131 ++++++++
 commands/github-copilot/inject-standards.md   | 298 ++++++++++++++++++
 commands/github-copilot/plan-product.md       | 211 +++++++++++++
 commands/github-copilot/shape-spec.md         | 274 ++++++++++++++++
 config.yml                                    |   8 +
 scripts/common-functions.sh                   |  30 ++
 scripts/project-install.sh                    | 111 +++++--
 8 files changed, 1257 insertions(+), 21 deletions(-)
 create mode 100644 commands/github-copilot/discover-standards.md
 create mode 100644 commands/github-copilot/index-standards.md
 create mode 100644 commands/github-copilot/inject-standards.md
 create mode 100644 commands/github-copilot/plan-product.md
 create mode 100644 commands/github-copilot/shape-spec.md

diff --git a/commands/github-copilot/discover-standards.md b/commands/github-copilot/discover-standards.md
new file mode 100644
index 00000000..8ebe3738
--- /dev/null
+++ b/commands/github-copilot/discover-standards.md
@@ -0,0 +1,215 @@
+# Discover Standards
+
+Extract tribal knowledge from your codebase into concise, documented standards.
+
+This GitHub Copilot agent skill helps you identify and document patterns, conventions, and tribal knowledge from your codebase that should be captured as standards.
+
+## GitHub Copilot Skills Integration
+
+This skill leverages GitHub Copilot's ability to:
+- Analyze codebases across multiple files
+- Identify patterns and conventions
+- Ask clarifying questions using interactive prompts
+- Create and organize documentation files
+
+## Important Guidelines
+
+- **Ask questions interactively** — Present options the user can confirm, choose between, or correct
+- **Write concise standards** — Use minimal words. Standards must be scannable by AI agents without bloating context windows.
+- **Offer suggestions** — Don't make users think harder than necessary.
+
+## Process
+
+### Step 1: Determine Focus Area
+
+Check if the user specified an area when running this command. If they did, skip to Step 2.
+
+If no area was specified:
+
+1. Analyze the codebase structure (folders, file types, patterns)
+2. Identify 3-5 major areas. Examples:
+   - **Frontend areas:** UI components, styling/CSS, state management, forms, routing
+   - **Backend areas:** API routes, database/models, authentication, background jobs
+   - **Cross-cutting:** Error handling, validation, testing, naming conventions, file structure
+3. Present the areas to the user:
+
+```
+I've identified these areas in your codebase:
+
+1. **API Routes** (src/api/) — Request handling, response formats
+2. **Database** (src/models/, src/db/) — Models, queries, migrations
+3. **React Components** (src/components/) — UI patterns, props, state
+4. **Authentication** (src/auth/) — Login, sessions, permissions
+
+Which area should we focus on for discovering standards? (Pick one, or suggest a different area)
+```
+
+Wait for user response before proceeding.
+
+### Step 2: Analyze & Present Findings
+
+Once an area is determined:
+
+1. Read key files in that area (5-10 representative files)
+2. Look for patterns that are:
+   - **Unusual or unconventional** — Not standard framework/library patterns
+   - **Opinionated** — Specific choices that could have gone differently
+   - **Tribal** — Things a new developer wouldn't know without being told
+   - **Consistent** — Patterns repeated across multiple files
+
+3. Present findings and let user select:
+
+```
+I analyzed [area] and found these potential standards worth documenting:
+
+1. **API Response Envelope** — All responses use { success, data, error } structure
+2. **Error Codes** — Custom error codes like AUTH_001, DB_002 with specific meanings
+3. **Pagination Pattern** — Cursor-based pagination with consistent param names
+
+Which would you like to document?
+
+Options:
+- "Yes, all of them"
+- "Just 1 and 3"
+- "Add: [your suggestion]"
+- "Skip this area"
+```
+
+Wait for user selection before proceeding.
+
+### Step 3: Ask Why, Then Draft Each Standard
+
+**IMPORTANT:** For each selected standard, you MUST complete this full loop before moving to the next standard:
+
+1. **Ask 1-2 clarifying questions** about the "why" behind the pattern
+2. **Wait for user response**
+3. **Draft the standard** incorporating their answer
+4. **Confirm with user** before creating the file
+5. **Create the file** if approved
+
+Example questions to ask (adapt based on the specific standard):
+
+- "What problem does this pattern solve? Why not use the default/common approach?"
+- "Are there exceptions where this pattern shouldn't be used?"
+- "What's the most common mistake a developer or agent makes with this?"
+
+**Do NOT batch all questions upfront.** Process one standard at a time through the full loop.
+
+### Step 4: Create the Standard File
+
+For each standard (after completing Step 3's Q&A):
+
+1. Determine the appropriate folder (create if needed):
+   - `api/`, `database/`, `javascript/`, `css/`, `backend/`, `testing/`, `global/`
+
+2. Check if a related standard file already exists — append to it if so
+
+3. Draft the content and confirm with user:
+
+```
+Here's the draft for api/response-format.md:
+
+---
+# API Response Format
+
+All API responses use this envelope:
+
+\`\`\`json
+{ "success": true, "data": { ... } }
+{ "success": false, "error": { "code": "...", "message": "..." } }
+\`\`\`
+
+- Never return raw data without the envelope
+- Error responses must include both code and message
+- Success responses omit the error field entirely
+---
+
+Create this file? (yes / edit: [your changes] / skip)
+```
+
+4. Create or update the file in `agent-os/standards/[folder]/`
+5. **Then repeat Steps 3-4 for the next selected standard**
+
+### Step 5: Update the Index
+
+After all standards are created:
+
+1. Scan `agent-os/standards/` for all `.md` files
+2. For each new file without an index entry, ask user:
+
+```
+New standard needs an index entry:
+  File: api/response-format.md
+
+Suggested description: "API response envelope structure and error format"
+
+Accept this description? (yes / or type a better one)
+```
+
+3. Update `agent-os/standards/index.yml`:
+
+```yaml
+api:
+  response-format:
+    description: API response envelope structure and error format
+```
+
+Alphabetize by folder, then by filename.
+
+### Step 6: Offer to Continue
+
+Ask the user:
+
+```
+Standards created for [area]:
+- api/response-format.md
+- api/error-codes.md
+
+Would you like to discover standards in another area, or are we done?
+```
+
+## Output Location
+
+All standards: `agent-os/standards/[folder]/[standard].md`
+Index file: `agent-os/standards/index.yml`
+
+## Writing Concise Standards
+
+Standards will be injected into AI context windows. Every word costs tokens. Follow these rules:
+
+- **Lead with the rule** — State what to do first, explain why second (if needed)
+- **Use code examples** — Show, don't tell
+- **Skip the obvious** — Don't document what the code already makes clear
+- **One standard per concept** — Don't combine unrelated patterns
+- **Bullet points over paragraphs** — Scannable beats readable
+
+**Good:**
+```markdown
+# Error Responses
+
+Use error codes: `AUTH_001`, `DB_001`, `VAL_001`
+
+\`\`\`json
+{ "success": false, "error": { "code": "AUTH_001", "message": "..." } }
+\`\`\`
+
+- Always include both code and message
+- Log full error server-side, return safe message to client
+```
+
+**Bad:**
+```markdown
+# Error Handling Guidelines
+
+When an error occurs in our application, we have established a consistent pattern for how errors should be formatted and returned to the client. This helps maintain consistency across our API and makes it easier for frontend developers to handle errors appropriately...
+[continues for 3 more paragraphs]
+```
+
+## GitHub Copilot Sub-Agent Usage
+
+When processing large codebases or complex analysis, consider using GitHub Copilot sub-agents to:
+- Analyze different areas of the codebase in parallel
+- Deep-dive into specific patterns or conventions
+- Generate draft standards for review
+
+Refer to [GitHub Copilot Agent Skills documentation](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills) for more details on creating and using sub-agents.
diff --git a/commands/github-copilot/index-standards.md b/commands/github-copilot/index-standards.md
new file mode 100644
index 00000000..51534e2d
--- /dev/null
+++ b/commands/github-copilot/index-standards.md
@@ -0,0 +1,131 @@
+# GitHub Copilot Agent Skill
+
+This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
+https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+
+---
+
+# Index Standards
+
+Rebuild and maintain the standards index file (`index.yml`).
+
+## Purpose
+
+The index enables `/inject-standards` to suggest relevant standards without reading all files. It maps each standard to a brief description for quick matching.
+
+## Process
+
+### Step 1: Scan for Standards Files
+
+1. List all `.md` files in `agent-os/standards/` and its subfolders
+2. Build a list of all standards organized by folder:
+   ```
+   root/coding-style.md        # Files in standards/ root use "root" as the folder name
+   root/naming.md
+   api/response-format.md
+   api/error-handling.md
+   database/migrations.md
+   ```
+
+**Note:** `root` is a reserved keyword — it refers to `.md` files directly in `agent-os/standards/` (not in a subfolder). Do not create an actual folder named "root".
+
+### Step 2: Load Existing Index
+
+Read `agent-os/standards/index.yml` if it exists. Note which entries already have descriptions.
+
+### Step 3: Identify Changes
+
+Compare the file scan with the existing index:
+
+- **New files** — Standards files without index entries
+- **Deleted files** — Index entries for files that no longer exist
+- **Existing files** — Already indexed, keep as-is
+
+### Step 4: Handle New Files
+
+For each new standard file that needs an index entry:
+
+1. Read the file to understand its content
+2. Use AskUserQuestion to propose a description:
+
+```
+New standard needs indexing:
+  File: api/response-format.md
+
+Suggested description: "API response envelope structure and error format"
+
+Accept? (yes / or type a better description)
+```
+
+Keep descriptions to **one short sentence** — they're for matching, not documentation.
+
+### Step 5: Handle Deleted Files
+
+If there are index entries for files that no longer exist:
+
+1. List them for the user
+2. Remove them from the index automatically (no confirmation needed)
+
+Report: "Removed 2 stale index entries: api/old-pattern.md, testing/deprecated.md"
+
+### Step 6: Write Updated Index
+
+Generate `agent-os/standards/index.yml` with this structure:
+
+```yaml
+folder-name:
+  file-name:
+    description: Brief description here
+```
+
+**Rules:**
+- Alphabetize folders
+- Alphabetize files within each folder
+- File names without `.md` extension
+- One-line descriptions only
+
+**Example:**
+```yaml
+root:
+  coding-style:
+    description: General coding style, formatting, linting rules
+  naming:
+    description: File naming, variable naming, class naming conventions
+
+api:
+  error-handling:
+    description: Error codes, exception handling, error response format
+  response-format:
+    description: API response envelope structure, status codes, pagination
+
+database:
+  migrations:
+    description: Migration file structure, naming conventions, rollback patterns
+```
+
+**Note:** `root` appears first and contains standards files that live directly in `agent-os/standards/` (not in subfolders).
+
+### Step 7: Report Results
+
+Summarize what changed:
+
+```
+Index updated:
+  ✓ 2 new entries added
+  ✓ 1 stale entry removed
+  ✓ 8 entries unchanged
+
+Total: 9 standards indexed
+```
+
+## When to Run
+
+- After manually creating or deleting standards files
+- If `/inject-standards` suggestions seem out of sync
+- To clean up a messy or outdated index
+
+**Note:** `/discover-standards` runs this automatically as its final step, so you usually don't need to call it separately after discovering standards.
+
+## Output
+
+Updates `agent-os/standards/index.yml`
diff --git a/commands/github-copilot/inject-standards.md b/commands/github-copilot/inject-standards.md
new file mode 100644
index 00000000..97d86c89
--- /dev/null
+++ b/commands/github-copilot/inject-standards.md
@@ -0,0 +1,298 @@
+# GitHub Copilot Agent Skill
+
+This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
+https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+
+---
+
+# Inject Standards
+
+Inject relevant standards into the current context, formatted appropriately for the situation.
+
+## Usage Modes
+
+This command supports two modes:
+
+### Auto-Suggest Mode (no arguments)
+```
+/inject-standards
+```
+Analyzes context and suggests relevant standards.
+
+### Explicit Mode (with arguments)
+```
+/inject-standards api                           # All standards in api/
+/inject-standards api/response-format           # Single file
+/inject-standards api/response-format api/auth  # Multiple files
+/inject-standards root                          # All standards in the root folder
+/inject-standards root/naming                   # Single file from root folder
+```
+Directly injects specified standards without suggestions.
+
+**Note:** `root` is a reserved keyword — it refers to `.md` files directly in `agent-os/standards/` (not in a subfolder).
+
+## Process
+
+### Step 1: Detect Context Scenario
+
+Before injecting standards, determine which scenario we're in. Read the current conversation and check if we're in plan mode.
+
+**Three scenarios:**
+
+1. **Conversation** — Regular chat, implementing code, answering questions
+2. **Creating a Skill** — Building a `.claude/skills/` file
+3. **Shaping/Planning** — In plan mode, building a spec, running `/shape-spec`
+
+**Detection logic:**
+
+- If currently in plan mode OR conversation clearly mentions "spec", "plan", "shape" → **Shaping/Planning**
+- If conversation clearly mentions creating a skill, editing `.claude/skills/`, or building a reusable procedure → **Creating a Skill**
+- Otherwise → **Ask to confirm** (do not assume)
+
+**If neither skill nor plan is clearly detected**, use AskUserQuestion to confirm:
+
+```
+I'll inject the relevant standards. How should I format them?
+
+1. **Conversation** — Read standards into our chat (for implementation work)
+2. **Skill** — Output file references to include in a skill you're building
+3. **Plan** — Output file references to include in a plan/spec
+
+Which scenario? (1, 2, or 3)
+```
+
+Always ask when uncertain — don't assume conversation by default.
+
+### Step 2: Read the Index (Auto-Suggest Mode)
+
+Read `agent-os/standards/index.yml` to get the list of available standards and their descriptions.
+
+If index.yml doesn't exist or is empty:
+```
+No standards index found. Run /discover-standards first to create standards,
+or /index-standards if you have standards files without an index.
+```
+
+### Step 3: Analyze Work Context
+
+Look at the current conversation to understand what the user is working on:
+- What type of work? (API, database, UI, etc.)
+- What technologies mentioned?
+- What's the goal?
+
+### Step 4: Match and Suggest
+
+Match index descriptions against the context. Use AskUserQuestion to present suggestions:
+
+```
+Based on your task, these standards may be relevant:
+
+1. **api/response-format** — API response envelope structure, status codes
+2. **api/error-handling** — Error codes, exception handling, error responses
+3. **global/naming** — File naming, variable naming conventions
+
+Inject these standards? (yes / just 1 and 3 / add: database/migrations / none)
+```
+
+Keep suggestions focused — typically 2-5 standards. Don't overwhelm with too many options.
+
+### Step 5: Inject Based on Scenario
+
+Format the output differently based on the detected scenario:
+
+---
+
+#### Scenario: Conversation
+
+Read the standards and announce them:
+
+```
+I've read the following standards as they are relevant to what we're working on:
+
+--- Standard: api/response-format ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+--- Standard: api/error-handling ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+**Key points:**
+- All API responses use { success, data, error } envelope
+- Error codes follow AUTH_xxx, DB_xxx pattern
+```
+
+---
+
+#### Scenario: Creating a Skill
+
+First, use AskUserQuestion to determine how to include the standards:
+
+```
+How should these standards be included in your skill?
+
+1. **References** — Add @ file paths that point to the standards (keeps skill lightweight, standards stay in sync)
+2. **Copy content** — Paste the full standards content into the skill (self-contained, but won't update if standards change)
+
+Which approach? (1 or 2)
+```
+
+**If References (option 1):**
+
+```
+Be sure to include references to the following standards files in the appropriate location in the file(s) that make up this skill:
+
+@agent-os/standards/api/response-format.md
+@agent-os/standards/api/error-handling.md
+@agent-os/standards/global/naming.md
+
+These standards cover:
+- API response envelope structure, status codes
+- Error codes, exception handling, error responses
+- File naming, variable naming conventions
+```
+
+**If Copy content (option 2):**
+
+```
+Include the following standards content in your skill:
+
+--- Standard: api/response-format ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+--- Standard: api/error-handling ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+These standards cover:
+- API response envelope structure, status codes
+- Error codes, exception handling, error responses
+- File naming, variable naming conventions
+```
+
+---
+
+#### Scenario: Shaping/Planning
+
+First, use AskUserQuestion to determine how to include the standards:
+
+```
+How should these standards be included in your plan?
+
+1. **References** — Add @ file paths that point to the standards (keeps plan lightweight, standards stay in sync)
+2. **Copy content** — Paste the full standards content into the plan (self-contained, but won't update if standards change)
+
+Which approach? (1 or 2)
+```
+
+**If References (option 1):**
+
+```
+Be sure to include references to the following standards files in the appropriate location in the plan we're building:
+
+@agent-os/standards/api/response-format.md
+@agent-os/standards/api/error-handling.md
+@agent-os/standards/global/naming.md
+
+These standards cover:
+- API response envelope structure, status codes
+- Error codes, exception handling, error responses
+- File naming, variable naming conventions
+```
+
+**If Copy content (option 2):**
+
+```
+Include the following standards content in your plan:
+
+--- Standard: api/response-format ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+--- Standard: api/error-handling ---
+
+[full content of the standard file]
+
+--- End Standard ---
+
+These standards cover:
+- API response envelope structure, status codes
+- Error codes, exception handling, error responses
+- File naming, variable naming conventions
+```
+
+---
+
+### Step 6: Surface Related Skills (Conversation scenario only)
+
+When in conversation scenario, check if `.claude/skills/` exists and contains related skills:
+
+```
+Related Skills you might want to use:
+- create-api-endpoint — Scaffolds new API endpoints following these standards
+```
+
+Don't invoke skills automatically — just surface them for awareness.
+
+---
+
+## Explicit Mode
+
+When arguments are provided, skip the suggestion step but still detect scenario.
+
+### Step 1: Detect Scenario
+
+Same as auto-suggest mode.
+
+### Step 2: Parse Arguments
+
+Arguments can be:
+- **Folder name** — `api` → inject all `.md` files in `agent-os/standards/api/`
+- **Folder/file** — `api/response-format` → inject `agent-os/standards/api/response-format.md`
+- **Root folder** — `root` → inject all `.md` files directly in `agent-os/standards/` (not in subfolders)
+- **Root file** — `root/naming` → inject `agent-os/standards/naming.md`
+
+Multiple arguments inject multiple standards.
+
+### Step 3: Validate
+
+Check that specified files/folders exist. If not:
+
+```
+Standard not found: api/nonexistent
+
+Available standards in api/:
+- response-format
+- error-handling
+- authentication
+
+Did you mean one of these?
+```
+
+### Step 4: Inject Based on Scenario
+
+Same formatting as auto-suggest mode, based on detected scenario.
+
+---
+
+## Tips
+
+- **Run early** — Inject standards at the start of a task, before implementation
+- **Be specific** — If you know which standards apply, use explicit mode
+- **Check the index** — If suggestions seem wrong, run `/index-standards` to rebuild
+- **Keep standards concise** — Injected standards consume tokens; shorter is better
+
+## Integration
+
+This command is called internally by `/shape-spec` to inject relevant standards during planning. You can also invoke it directly anytime you need standards in context.
diff --git a/commands/github-copilot/plan-product.md b/commands/github-copilot/plan-product.md
new file mode 100644
index 00000000..518bbfe2
--- /dev/null
+++ b/commands/github-copilot/plan-product.md
@@ -0,0 +1,211 @@
+# GitHub Copilot Agent Skill
+
+This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
+https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+
+---
+
+# Plan Product
+
+Establish foundational product documentation through an interactive conversation. Creates mission, roadmap, and tech stack files in `agent-os/product/`.
+
+## Important Guidelines
+
+- **Always use AskUserQuestion tool** when asking the user anything
+- **Keep it lightweight** — gather enough to create useful docs without over-documenting
+- **One question at a time** — don't overwhelm with multiple questions
+
+## Process
+
+### Step 1: Check for Existing Product Docs
+
+Check if `agent-os/product/` exists and contains any of these files:
+- `mission.md`
+- `roadmap.md`
+- `tech-stack.md`
+
+**If any files exist**, use AskUserQuestion:
+
+```
+I found existing product documentation:
+- mission.md: [exists/missing]
+- roadmap.md: [exists/missing]
+- tech-stack.md: [exists/missing]
+
+Would you like to:
+1. Start fresh (replace all)
+2. Update specific files
+3. Cancel
+
+(Choose 1, 2, or 3)
+```
+
+If option 2, ask which files to update and only gather info for those.
+If option 3, stop here.
+
+**If no files exist**, proceed to Step 2.
+
+### Step 2: Gather Product Vision (for mission.md)
+
+Use AskUserQuestion:
+
+```
+Let's define your product's mission.
+
+**What problem does this product solve?**
+
+(Describe the core problem or pain point you're addressing)
+```
+
+After they respond, use AskUserQuestion:
+
+```
+**Who is this product for?**
+
+(Describe your target users or audience)
+```
+
+After they respond, use AskUserQuestion:
+
+```
+**What makes your solution unique?**
+
+(What's the key differentiator or approach?)
+```
+
+### Step 3: Gather Roadmap (for roadmap.md)
+
+Use AskUserQuestion:
+
+```
+Now let's outline your development roadmap.
+
+**What are the must-have features for launch (MVP)?**
+
+(List the core features needed for the first usable version)
+```
+
+After they respond, use AskUserQuestion:
+
+```
+**What features are planned for after launch?**
+
+(List features you'd like to add in future phases, or say "none yet")
+```
+
+### Step 4: Establish Tech Stack (for tech-stack.md)
+
+First, check if `agent-os/standards/global/tech-stack.md` exists.
+
+**If the tech-stack standard exists**, read it and use AskUserQuestion:
+
+```
+I found a tech stack standard in your standards:
+
+[Summarize the key technologies from global/tech-stack.md]
+
+Does this project use the same tech stack, or does it differ?
+
+1. Same as standard (use as-is)
+2. Different (I'll specify)
+
+(Choose 1 or 2)
+```
+
+If they choose option 1, use the standard's content for tech-stack.md.
+If they choose option 2, proceed to ask them to specify (see below).
+
+**If no tech-stack standard exists** (or they chose option 2 above), use AskUserQuestion:
+
+```
+**What technologies does this project use?**
+
+Please describe your tech stack:
+- Frontend: (e.g., React, Vue, vanilla JS, or N/A)
+- Backend: (e.g., Rails, Node, Django, or N/A)
+- Database: (e.g., PostgreSQL, MongoDB, or N/A)
+- Other: (hosting, APIs, tools, etc.)
+```
+
+### Step 5: Generate Files
+
+Create the `agent-os/product/` directory if it doesn't exist.
+
+Generate each file based on the information gathered:
+
+#### mission.md
+
+```markdown
+# Product Mission
+
+## Problem
+
+[Insert what problem this product solves - from Step 2]
+
+## Target Users
+
+[Insert who this product is for - from Step 2]
+
+## Solution
+
+[Insert what makes the solution unique - from Step 2]
+```
+
+#### roadmap.md
+
+```markdown
+# Product Roadmap
+
+## Phase 1: MVP
+
+[Insert must-have features for launch - from Step 3]
+
+## Phase 2: Post-Launch
+
+[Insert planned future features - from Step 3, or "To be determined" if they said none yet]
+```
+
+#### tech-stack.md
+
+```markdown
+# Tech Stack
+
+[Organize the tech stack information into logical sections]
+
+## Frontend
+
+[Frontend technologies, or "N/A" if not applicable]
+
+## Backend
+
+[Backend technologies, or "N/A" if not applicable]
+
+## Database
+
+[Database choice, or "N/A" if not applicable]
+
+## Other
+
+[Other tools, hosting, services - or omit this section if nothing mentioned]
+```
+
+### Step 6: Confirm Completion
+
+After creating all files, output to user:
+
+```
+✓ Product documentation created:
+
+  agent-os/product/mission.md
+  agent-os/product/roadmap.md
+  agent-os/product/tech-stack.md
+
+Review these files to ensure they accurately capture your product vision.
+You can edit them directly or run /plan-product again to update.
+```
+
+## Tips
+
+- If the user provides very brief answers, that's fine — the docs can be expanded later
+- If they want to skip a section, create the file with a placeholder like "To be defined"
+- The `/shape-spec` command will read these files when planning features, so having them populated helps with context
diff --git a/commands/github-copilot/shape-spec.md b/commands/github-copilot/shape-spec.md
new file mode 100644
index 00000000..760d5ca3
--- /dev/null
+++ b/commands/github-copilot/shape-spec.md
@@ -0,0 +1,274 @@
+# GitHub Copilot Agent Skill
+
+This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
+https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+
+---
+
+# Shape Spec
+
+Gather context and structure planning for significant work. **Run this command while in plan mode.**
+
+## Important Guidelines
+
+- **Always use AskUserQuestion tool** when asking the user anything
+- **Offer suggestions** — Present options the user can confirm, adjust, or correct
+- **Keep it lightweight** — This is shaping, not exhaustive documentation
+
+## Prerequisites
+
+This command **must be run in plan mode**.
+
+**Before proceeding, check if you are currently in plan mode.**
+
+If NOT in plan mode, **stop immediately** and tell the user:
+
+```
+Shape-spec must be run in plan mode. Please enter plan mode first, then run /shape-spec again.
+```
+
+Do not proceed with any steps below until confirmed to be in plan mode.
+
+## Process
+
+### Step 1: Clarify What We're Building
+
+Use AskUserQuestion to understand the scope:
+
+```
+What are we building? Please describe the feature or change.
+
+(Be as specific as you like — I'll ask follow-up questions if needed)
+```
+
+Based on their response, ask 1-2 clarifying questions if the scope is unclear. Examples:
+- "Is this a new feature or a change to existing functionality?"
+- "What's the expected outcome when this is done?"
+- "Are there any constraints or requirements I should know about?"
+
+### Step 2: Gather Visuals
+
+Use AskUserQuestion:
+
+```
+Do you have any visuals to reference?
+
+- Mockups or wireframes
+- Screenshots of similar features
+- Examples from other apps
+
+(Paste images, share file paths, or say "none")
+```
+
+If visuals are provided, note them for inclusion in the spec folder.
+
+### Step 3: Identify Reference Implementations
+
+Use AskUserQuestion:
+
+```
+Is there similar code in this codebase I should reference?
+
+Examples:
+- "The comments feature is similar to what we're building"
+- "Look at how src/features/notifications/ handles real-time updates"
+- "No existing references"
+
+(Point me to files, folders, or features to study)
+```
+
+If references are provided, read and analyze them to inform the plan.
+
+### Step 4: Check Product Context
+
+Check if `agent-os/product/` exists and contains files.
+
+If it exists, read key files (like `mission.md`, `roadmap.md`, `tech-stack.md`) and use AskUserQuestion:
+
+```
+I found product context in agent-os/product/. Should this feature align with any specific product goals or constraints?
+
+Key points from your product docs:
+- [summarize relevant points]
+
+(Confirm alignment or note any adjustments)
+```
+
+If no product folder exists, skip this step.
+
+### Step 5: Surface Relevant Standards
+
+Read `agent-os/standards/index.yml` to identify relevant standards based on the feature being built.
+
+Use AskUserQuestion to confirm:
+
+```
+Based on what we're building, these standards may apply:
+
+1. **api/response-format** — API response envelope structure
+2. **api/error-handling** — Error codes and exception handling
+3. **database/migrations** — Migration patterns
+
+Should I include these in the spec? (yes / adjust: remove 3, add frontend/forms)
+```
+
+Read the confirmed standards files to include their content in the plan context.
+
+### Step 6: Generate Spec Folder Name
+
+Create a folder name using this format:
+```
+YYYY-MM-DD-HHMM-{feature-slug}/
+```
+
+Where:
+- Date/time is current timestamp
+- Feature slug is derived from the feature description (lowercase, hyphens, max 40 chars)
+
+Example: `2026-01-15-1430-user-comment-system/`
+
+**Note:** If `agent-os/specs/` doesn't exist, create it when saving the spec folder.
+
+### Step 7: Structure the Plan
+
+Now build the plan with **Task 1 always being "Save spec documentation"**.
+
+Present this structure to the user:
+
+```
+Here's the plan structure. Task 1 saves all our shaping work before implementation begins.
+
+---
+
+## Task 1: Save Spec Documentation
+
+Create `agent-os/specs/{folder-name}/` with:
+
+- **plan.md** — This full plan
+- **shape.md** — Shaping notes (scope, decisions, context from our conversation)
+- **standards.md** — Relevant standards that apply to this work
+- **references.md** — Pointers to reference implementations studied
+- **visuals/** — Any mockups or screenshots provided
+
+## Task 2: [First implementation task]
+
+[Description based on the feature]
+
+## Task 3: [Next task]
+
+...
+
+---
+
+Does this plan structure look right? I'll fill in the implementation tasks next.
+```
+
+### Step 8: Complete the Plan
+
+After Task 1 is confirmed, continue building out the remaining implementation tasks based on:
+- The feature scope from Step 1
+- Patterns from reference implementations (Step 3)
+- Constraints from standards (Step 5)
+
+Each task should be specific and actionable.
+
+### Step 9: Ready for Execution
+
+When the full plan is ready:
+
+```
+Plan complete. When you approve and execute:
+
+1. Task 1 will save all spec documentation first
+2. Then implementation tasks will proceed
+
+Ready to start? (approve / adjust)
+```
+
+## Output Structure
+
+The spec folder will contain:
+
+```
+agent-os/specs/{YYYY-MM-DD-HHMM-feature-slug}/
+├── plan.md           # The full plan
+├── shape.md          # Shaping decisions and context
+├── standards.md      # Which standards apply and key points
+├── references.md     # Pointers to similar code
+└── visuals/          # Mockups, screenshots (if any)
+```
+
+## shape.md Content
+
+The shape.md file should capture:
+
+```markdown
+# {Feature Name} — Shaping Notes
+
+## Scope
+
+[What we're building, from Step 1]
+
+## Decisions
+
+- [Key decisions made during shaping]
+- [Constraints or requirements noted]
+
+## Context
+
+- **Visuals:** [List of visuals provided, or "None"]
+- **References:** [Code references studied]
+- **Product alignment:** [Notes from product context, or "N/A"]
+
+## Standards Applied
+
+- api/response-format — [why it applies]
+- api/error-handling — [why it applies]
+```
+
+## standards.md Content
+
+Include the full content of each relevant standard:
+
+```markdown
+# Standards for {Feature Name}
+
+The following standards apply to this work.
+
+---
+
+## api/response-format
+
+[Full content of the standard file]
+
+---
+
+## api/error-handling
+
+[Full content of the standard file]
+```
+
+## references.md Content
+
+```markdown
+# References for {Feature Name}
+
+## Similar Implementations
+
+### {Reference 1 name}
+
+- **Location:** `src/features/comments/`
+- **Relevance:** [Why this is relevant]
+- **Key patterns:** [What to borrow from this]
+
+### {Reference 2 name}
+
+...
+```
+
+## Tips
+
+- **Keep shaping fast** — Don't over-document. Capture enough to start, refine as you build.
+- **Visuals are optional** — Not every feature needs mockups.
+- **Standards guide, not dictate** — They inform the plan but aren't always mandatory.
+- **Specs are discoverable** — Months later, someone can find this spec and understand what was built and why.
diff --git a/config.yml b/config.yml
index afb94a8f..158bc5c0 100644
--- a/config.yml
+++ b/config.yml
@@ -1,6 +1,14 @@
 version: 3.0
 default_profile: default
 
+# AI Agent Configuration
+# Specify which AI agent(s) to use: claude, github-copilot, or both
+# Default: claude (for backward compatibility)
+ai_agents:
+  - claude
+# To add GitHub Copilot support, uncomment the line below:
+# - github-copilot
+
 # Optional: define inheritance relationships for profiles
 # Profiles not listed here still work, they just have no inheritance
 # profiles:
diff --git a/scripts/common-functions.sh b/scripts/common-functions.sh
index d04a63df..0f1f9680 100755
--- a/scripts/common-functions.sh
+++ b/scripts/common-functions.sh
@@ -177,6 +177,36 @@ get_profile_inheritance_chain() {
     echo "$chain"
 }
 
+# Get AI agents list from YAML (returns comma-separated list)
+get_yaml_agents() {
+    local file=$1
+    local default=$2
+
+    if [[ ! -f "$file" ]]; then
+        echo "$default"
+        return
+    fi
+
+    # Use awk to extract agents from the ai_agents array
+    local agents=$(awk '
+        /^ai_agents:/ { in_agents=1; next }
+        /^[a-zA-Z]/ && !/^[[:space:]]/ { in_agents=0 }
+        in_agents && /^[[:space:]]*-[[:space:]]*/ {
+            gsub(/^[[:space:]]*-[[:space:]]*/, "")
+            gsub(/[[:space:]]*$/, "")
+            gsub(/#.*$/, "")  # Remove comments
+            gsub(/^[[:space:]]*/, "")
+            if (length($0) > 0) print $0
+        }
+    ' "$file" | paste -sd "," -)
+
+    if [[ -n "$agents" ]]; then
+        echo "$agents"
+    else
+        echo "$default"
+    fi
+}
+
 # -----------------------------------------------------------------------------
 # File Operations
 # -----------------------------------------------------------------------------
diff --git a/scripts/project-install.sh b/scripts/project-install.sh
index 8688d4ad..9e351b4f 100755
--- a/scripts/project-install.sh
+++ b/scripts/project-install.sh
@@ -22,6 +22,7 @@ source "$SCRIPT_DIR/common-functions.sh"
 VERBOSE="false"
 PROFILE=""
 COMMANDS_ONLY="false"
+AGENTS=""  # Comma-separated list of agents (claude, github-copilot, or both)
 
 # -----------------------------------------------------------------------------
 # Help Function
@@ -35,6 +36,8 @@ Install Agent OS into the current project directory.
 
 Options:
     --profile <name>     Use specified profile (default: from config.yml)
+    --agents <list>      Comma-separated list of agents to install: claude, github-copilot, or both
+                         (default: from config.yml or claude if not specified)
     --commands-only      Only update commands, preserve existing standards
     --verbose            Show detailed output
     -h, --help           Show this help message
@@ -42,6 +45,8 @@ Options:
 Examples:
     $0
     $0 --profile rails
+    $0 --agents claude,github-copilot
+    $0 --agents github-copilot
     $0 --commands-only
 
 EOF
@@ -59,6 +64,10 @@ parse_arguments() {
                 PROFILE="$2"
                 shift 2
                 ;;
+            --agents)
+                AGENTS="$2"
+                shift 2
+                ;;
             --commands-only)
                 COMMANDS_ONLY="true"
                 shift
@@ -124,6 +133,25 @@ load_configuration() {
         exit 1
     fi
 
+    # Get AI agents configuration
+    local default_agents="claude"
+    local config_agents=$(get_yaml_agents "$config_file" "$default_agents")
+    
+    # Use command line agents or config default
+    EFFECTIVE_AGENTS="${AGENTS:-$config_agents}"
+    
+    # Validate agents
+    IFS=',' read -ra AGENT_ARRAY <<< "$EFFECTIVE_AGENTS"
+    for agent in "${AGENT_ARRAY[@]}"; do
+        agent=$(echo "$agent" | xargs)  # Trim whitespace
+        if [[ "$agent" != "claude" && "$agent" != "github-copilot" ]]; then
+            print_error "Invalid agent: $agent"
+            echo ""
+            echo "Valid agents are: claude, github-copilot"
+            exit 1
+        fi
+    done
+
     # Build inheritance chain
     local chain_result=$(get_profile_inheritance_chain "$config_file" "$EFFECTIVE_PROFILE" "$BASE_DIR/profiles")
 
@@ -385,28 +413,68 @@ install_commands() {
     echo ""
     print_status "Installing commands..."
 
-    local commands_source="$BASE_DIR/commands/agent-os"
-    local commands_dest="$PROJECT_DIR/.claude/commands/agent-os"
-
-    if [[ ! -d "$commands_source" ]]; then
-        print_warning "No commands found in base installation"
-        return
-    fi
-
-    ensure_dir "$commands_dest"
-
-    local count=0
-    for file in "$commands_source"/*.md; do
-        if [[ -f "$file" ]]; then
-            cp "$file" "$commands_dest/"
-            ((count++))
-        fi
+    local installed_count=0
+    
+    # Install commands for each agent
+    IFS=',' read -ra AGENT_ARRAY <<< "$EFFECTIVE_AGENTS"
+    for agent in "${AGENT_ARRAY[@]}"; do
+        agent=$(echo "$agent" | xargs)  # Trim whitespace
+        
+        case "$agent" in
+            claude)
+                local commands_source="$BASE_DIR/commands/agent-os"
+                local commands_dest="$PROJECT_DIR/.claude/commands/agent-os"
+                
+                if [[ ! -d "$commands_source" ]]; then
+                    print_warning "No Claude commands found in base installation"
+                    continue
+                fi
+                
+                ensure_dir "$commands_dest"
+                
+                local count=0
+                for file in "$commands_source"/*.md; do
+                    if [[ -f "$file" ]]; then
+                        cp "$file" "$commands_dest/"
+                        ((count++))
+                    fi
+                done
+                
+                if [[ "$count" -gt 0 ]]; then
+                    print_success "Installed $count Claude commands to .claude/commands/agent-os/"
+                    ((installed_count+=count))
+                fi
+                ;;
+                
+            github-copilot)
+                local commands_source="$BASE_DIR/commands/github-copilot"
+                local commands_dest="$PROJECT_DIR/.github/copilot/agent-os"
+                
+                if [[ ! -d "$commands_source" ]]; then
+                    print_warning "No GitHub Copilot commands found in base installation"
+                    continue
+                fi
+                
+                ensure_dir "$commands_dest"
+                
+                local count=0
+                for file in "$commands_source"/*.md; do
+                    if [[ -f "$file" ]]; then
+                        cp "$file" "$commands_dest/"
+                        ((count++))
+                    fi
+                done
+                
+                if [[ "$count" -gt 0 ]]; then
+                    print_success "Installed $count GitHub Copilot agent skills to .github/copilot/agent-os/"
+                    ((installed_count+=count))
+                fi
+                ;;
+        esac
     done
-
-    if [[ "$count" -gt 0 ]]; then
-        print_success "Installed $count commands to .claude/commands/agent-os/"
-    else
-        print_warning "No command files found"
+    
+    if [[ "$installed_count" -eq 0 ]]; then
+        print_warning "No command files found for any agent"
     fi
 }
 
@@ -451,6 +519,7 @@ main() {
     done <<< "$reversed_chain"
     echo "$chain_display"
 
+    echo "  AI Agents: $EFFECTIVE_AGENTS"
     echo "  Commands only: $COMMANDS_ONLY"
 
     # Confirm overwrite if standards folder exists

From 931fdee1be04a0cd377b0f8bebb6c6a689e6724c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 13:19:04 +0000
Subject: [PATCH 2/9] Fix arithmetic expression issues with set -e in
 installation script

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 scripts/project-install.sh | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/scripts/project-install.sh b/scripts/project-install.sh
index 9e351b4f..c2c17ffe 100755
--- a/scripts/project-install.sh
+++ b/scripts/project-install.sh
@@ -273,7 +273,7 @@ install_standards() {
         done < <(find "$profile_standards" -name "*.md" -type f ! -path "*/.backups/*" -print0 2>/dev/null)
 
         if [[ "$profile_file_count" -gt 0 ]]; then
-            ((profiles_used++))
+            profiles_used=$((profiles_used + 1))
         fi
     done <<< "$INHERITANCE_CHAIN"
 
@@ -367,7 +367,7 @@ create_index() {
             fi
             echo "  $filename:" >> "$temp_file"
             echo "    description: $desc" >> "$temp_file"
-            ((entry_count++))
+            entry_count=$((entry_count + 1))
         done <<< "$root_files"
         echo "" >> "$temp_file"
     fi
@@ -389,7 +389,7 @@ create_index() {
                 fi
                 echo "  $filename:" >> "$temp_file"
                 echo "    description: $desc" >> "$temp_file"
-                ((entry_count++))
+                entry_count=$((entry_count + 1))
             done <<< "$md_files"
             echo "" >> "$temp_file"
         fi
@@ -436,13 +436,13 @@ install_commands() {
                 for file in "$commands_source"/*.md; do
                     if [[ -f "$file" ]]; then
                         cp "$file" "$commands_dest/"
-                        ((count++))
+                        count=$((count + 1))
                     fi
                 done
                 
                 if [[ "$count" -gt 0 ]]; then
                     print_success "Installed $count Claude commands to .claude/commands/agent-os/"
-                    ((installed_count+=count))
+                    installed_count=$((installed_count + count))
                 fi
                 ;;
                 
@@ -461,13 +461,13 @@ install_commands() {
                 for file in "$commands_source"/*.md; do
                     if [[ -f "$file" ]]; then
                         cp "$file" "$commands_dest/"
-                        ((count++))
+                        count=$((count + 1))
                     fi
                 done
                 
                 if [[ "$count" -gt 0 ]]; then
                     print_success "Installed $count GitHub Copilot agent skills to .github/copilot/agent-os/"
-                    ((installed_count+=count))
+                    installed_count=$((installed_count + count))
                 fi
                 ;;
         esac
@@ -515,7 +515,7 @@ main() {
             done
             chain_display="$chain_display"$'\n'"$indent  ↳ inherits from: $profile_name"
         fi
-        ((chain_depth++))
+        chain_depth=$((chain_depth + 1))
     done <<< "$reversed_chain"
     echo "$chain_display"
 

From 396e680e3f370bd7ec6104c1c125a002a8178b2a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 13:19:58 +0000
Subject: [PATCH 3/9] Add documentation for GitHub Copilot support

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 GITHUB_COPILOT.md | 189 ++++++++++++++++++++++++++++++++++++++++++++++
 README.md         |  32 +++++++-
 2 files changed, 220 insertions(+), 1 deletion(-)
 create mode 100644 GITHUB_COPILOT.md

diff --git a/GITHUB_COPILOT.md b/GITHUB_COPILOT.md
new file mode 100644
index 00000000..11e1adb7
--- /dev/null
+++ b/GITHUB_COPILOT.md
@@ -0,0 +1,189 @@
+# GitHub Copilot Integration Guide
+
+Agent OS provides full support for GitHub Copilot as an AI agent, with commands implemented as GitHub Copilot agent skills.
+
+## What is GitHub Copilot Agent Skills?
+
+GitHub Copilot agent skills are reusable, composable units of functionality that extend GitHub Copilot's capabilities. They allow you to:
+
+- Create custom workflows and procedures
+- Leverage sub-agents for parallel task execution
+- Build domain-specific AI assistance
+- Integrate with your project's standards and conventions
+
+Learn more: [GitHub Copilot Agent Skills Documentation](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills)
+
+## Installation
+
+### Option 1: Configure in config.yml
+
+Edit your `config.yml` to include GitHub Copilot:
+
+```yaml
+version: 3.0
+default_profile: default
+
+ai_agents:
+  - claude
+  - github-copilot  # Add this line
+```
+
+Then run the installation:
+
+```bash
+./scripts/project-install.sh
+```
+
+### Option 2: Command Line Flag
+
+Install directly with the `--agents` flag:
+
+```bash
+# GitHub Copilot only
+./scripts/project-install.sh --agents github-copilot
+
+# Both Claude and GitHub Copilot
+./scripts/project-install.sh --agents claude,github-copilot
+```
+
+## Available Skills
+
+Agent OS provides the following GitHub Copilot agent skills:
+
+### 1. Discover Standards
+**Location:** `.github/copilot/agent-os/discover-standards.md`
+
+Extract tribal knowledge from your codebase into concise, documented standards. This skill helps identify patterns, conventions, and best practices that should be captured as reusable standards.
+
+### 2. Inject Standards
+**Location:** `.github/copilot/agent-os/inject-standards.md`
+
+Intelligently inject relevant standards into your current context. Supports:
+- Auto-suggestion based on current work
+- Explicit standard selection
+- Integration with conversations, skills, and plans
+
+### 3. Index Standards
+**Location:** `.github/copilot/agent-os/index-standards.md`
+
+Rebuild and maintain the standards index file (`index.yml`) for quick discovery and matching.
+
+### 4. Shape Spec
+**Location:** `.github/copilot/agent-os/shape-spec.md`
+
+Gather context and structure planning for significant work. Works in plan mode to create well-scoped and strategized plans.
+
+### 5. Plan Product
+**Location:** `.github/copilot/agent-os/plan-product.md`
+
+Establish foundational product documentation through an interactive conversation. Creates mission, roadmap, and tech stack files.
+
+## Using GitHub Copilot Skills
+
+### In GitHub Copilot Chat
+
+Reference skills directly in your conversation:
+
+```
+@github Use the discover-standards skill to identify API patterns in src/api/
+```
+
+### In Workflow Files
+
+Skills can be referenced in GitHub Actions or other CI/CD workflows that support GitHub Copilot integration.
+
+### With Sub-Agents
+
+GitHub Copilot skills support sub-agents for parallel execution:
+
+```
+@github Use discover-standards skill with sub-agents to analyze:
+1. API patterns in src/api/
+2. Database patterns in src/models/
+3. UI patterns in src/components/
+```
+
+## Directory Structure
+
+When installed, GitHub Copilot agent skills are placed in:
+
+```
+.github/
+└── copilot/
+    └── agent-os/
+        ├── discover-standards.md
+        ├── inject-standards.md
+        ├── index-standards.md
+        ├── plan-product.md
+        └── shape-spec.md
+```
+
+## Standards Directory
+
+Regardless of which AI agent you use, standards are stored in:
+
+```
+agent-os/
+└── standards/
+    ├── index.yml
+    ├── api/
+    ├── database/
+    ├── global/
+    └── [other domains]/
+```
+
+## Differences from Claude Code
+
+While the core functionality is the same, there are some differences in how skills are invoked:
+
+| Feature | Claude Code | GitHub Copilot |
+|---------|-------------|----------------|
+| Command prefix | `/` | `@github` |
+| Location | `.claude/commands/` | `.github/copilot/` |
+| Sub-agents | Claude sub-agents | GitHub Copilot sub-agents |
+| Skills format | Markdown commands | Agent skills |
+
+## Benefits of GitHub Copilot Integration
+
+1. **Native GitHub Integration** — Skills work seamlessly with GitHub features
+2. **Sub-Agent Support** — Leverage parallel task execution for complex workflows
+3. **Enterprise Features** — Access GitHub Copilot Enterprise capabilities
+4. **Version Control** — Skills are versioned with your codebase
+5. **Team Collaboration** — Share standards and skills across your team
+
+## Updating Skills
+
+To update your GitHub Copilot skills to the latest version:
+
+```bash
+./scripts/project-install.sh --commands-only --agents github-copilot
+```
+
+This will update the skills without touching your existing standards.
+
+## Troubleshooting
+
+### Skills not appearing in GitHub Copilot
+
+1. Ensure skills are in `.github/copilot/` directory
+2. Check file permissions (should be readable)
+3. Verify GitHub Copilot is enabled for your repository
+4. Try restarting your IDE
+
+### Standards not being found
+
+1. Run `/index-standards` to rebuild the index
+2. Check that `agent-os/standards/index.yml` exists
+3. Verify standards files are in the correct subdirectories
+
+## Additional Resources
+
+- [Agent OS Documentation](https://buildermethods.com/agent-os)
+- [GitHub Copilot Skills Documentation](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills)
+- [Agent OS Changelog](CHANGELOG.md)
+
+## Support
+
+For questions and support:
+- [GitHub Issues](https://github.com/buildermethods/agent-os/issues)
+- [Builder Methods Pro Community](https://buildermethods.com/pro)
diff --git a/README.md b/README.md
index 78e2756d..6ce74c7b 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 [Agent OS](https://buildermethods.com/agent-os) helps you shape better specs, keeps agents aligned in a lightweight system that fits how you already build.
 
-Works alongside Claude Code, Cursor, Antigravity, and other AI tools. Any language, any framework.
+Works alongside **Claude Code**, **GitHub Copilot**, **Cursor**, **Antigravity**, and other AI tools. Any language, any framework.
 
 **Core capabilities:**
 
@@ -15,6 +15,36 @@ Works alongside Claude Code, Cursor, Antigravity, and other AI tools. Any langua
 
 ---
 
+### AI Agent Support
+
+Agent OS now supports multiple AI agents:
+- **Claude Code** — Commands installed to `.claude/commands/agent-os/`
+- **GitHub Copilot** — Agent skills installed to `.github/copilot/agent-os/`
+
+You can configure your preferred AI agent(s) in `config.yml`:
+
+```yaml
+ai_agents:
+  - claude          # For Claude Code support
+  # - github-copilot  # Uncomment for GitHub Copilot support
+```
+
+Or specify during installation:
+```bash
+# Install for Claude only (default)
+./scripts/project-install.sh --agents claude
+
+# Install for GitHub Copilot only
+./scripts/project-install.sh --agents github-copilot
+
+# Install for both agents
+./scripts/project-install.sh --agents claude,github-copilot
+```
+
+**GitHub Copilot Integration:** Agent OS commands are provided as GitHub Copilot agent skills, leveraging the [GitHub Copilot Skills framework](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills) for enhanced AI-assisted development with support for sub-agents and parallel task execution.
+
+---
+
 ### Documentation & Installation
 
 Docs, installation, usage, & best practices 👉 [It's all here](https://buildermethods.com/agent-os)

From af7c880f4033f4c2dc760193743265ff130bb45c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 13:21:04 +0000
Subject: [PATCH 4/9] Fix code review feedback: add header to
 discover-standards and fix capitalization

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 commands/github-copilot/discover-standards.md | 9 ++++++++-
 scripts/project-install.sh                    | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/commands/github-copilot/discover-standards.md b/commands/github-copilot/discover-standards.md
index 8ebe3738..8b310df7 100644
--- a/commands/github-copilot/discover-standards.md
+++ b/commands/github-copilot/discover-standards.md
@@ -1,8 +1,15 @@
+# GitHub Copilot Agent Skill
+
+This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
+https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+
+---
+
 # Discover Standards
 
 Extract tribal knowledge from your codebase into concise, documented standards.
 
-This GitHub Copilot agent skill helps you identify and document patterns, conventions, and tribal knowledge from your codebase that should be captured as standards.
+This skill helps you identify and document patterns, conventions, and tribal knowledge from your codebase that should be captured as standards.
 
 ## GitHub Copilot Skills Integration
 
diff --git a/scripts/project-install.sh b/scripts/project-install.sh
index c2c17ffe..44f05238 100755
--- a/scripts/project-install.sh
+++ b/scripts/project-install.sh
@@ -519,7 +519,7 @@ main() {
     done <<< "$reversed_chain"
     echo "$chain_display"
 
-    echo "  AI Agents: $EFFECTIVE_AGENTS"
+    echo "  AI agents: $EFFECTIVE_AGENTS"
     echo "  Commands only: $COMMANDS_ONLY"
 
     # Confirm overwrite if standards folder exists

From 8e1958c76cd32a2c309c365c39d9547917bd370c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:12:27 +0000
Subject: [PATCH 5/9] Restructure GitHub Copilot skills to follow proper format
 with SKILL.md files

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 GITHUB_COPILOT.md                             | 54 +++++++++++++------
 .../SKILL.md}                                 | 18 ++-----
 .../SKILL.md}                                 |  9 ++--
 .../SKILL.md}                                 |  9 ++--
 .../SKILL.md}                                 |  9 ++--
 .../{shape-spec.md => shape-spec/SKILL.md}    |  9 ++--
 scripts/project-install.sh                    | 15 +++---
 7 files changed, 62 insertions(+), 61 deletions(-)
 rename commands/github-copilot/{discover-standards.md => discover-standards/SKILL.md} (91%)
 rename commands/github-copilot/{index-standards.md => index-standards/SKILL.md} (94%)
 rename commands/github-copilot/{inject-standards.md => inject-standards/SKILL.md} (97%)
 rename commands/github-copilot/{plan-product.md => plan-product/SKILL.md} (95%)
 rename commands/github-copilot/{shape-spec.md => shape-spec/SKILL.md} (96%)

diff --git a/GITHUB_COPILOT.md b/GITHUB_COPILOT.md
index 11e1adb7..9540beea 100644
--- a/GITHUB_COPILOT.md
+++ b/GITHUB_COPILOT.md
@@ -51,12 +51,12 @@ Install directly with the `--agents` flag:
 Agent OS provides the following GitHub Copilot agent skills:
 
 ### 1. Discover Standards
-**Location:** `.github/copilot/agent-os/discover-standards.md`
+**Location:** `.github/skills/discover-standards/SKILL.md`
 
 Extract tribal knowledge from your codebase into concise, documented standards. This skill helps identify patterns, conventions, and best practices that should be captured as reusable standards.
 
 ### 2. Inject Standards
-**Location:** `.github/copilot/agent-os/inject-standards.md`
+**Location:** `.github/skills/inject-standards/SKILL.md`
 
 Intelligently inject relevant standards into your current context. Supports:
 - Auto-suggestion based on current work
@@ -64,28 +64,40 @@ Intelligently inject relevant standards into your current context. Supports:
 - Integration with conversations, skills, and plans
 
 ### 3. Index Standards
-**Location:** `.github/copilot/agent-os/index-standards.md`
+**Location:** `.github/skills/index-standards/SKILL.md`
 
 Rebuild and maintain the standards index file (`index.yml`) for quick discovery and matching.
 
 ### 4. Shape Spec
-**Location:** `.github/copilot/agent-os/shape-spec.md`
+**Location:** `.github/skills/shape-spec/SKILL.md`
 
 Gather context and structure planning for significant work. Works in plan mode to create well-scoped and strategized plans.
 
 ### 5. Plan Product
-**Location:** `.github/copilot/agent-os/plan-product.md`
+**Location:** `.github/skills/plan-product/SKILL.md`
 
 Establish foundational product documentation through an interactive conversation. Creates mission, roadmap, and tech stack files.
 
 ## Using GitHub Copilot Skills
 
+### In GitHub Copilot CLI
+
+Skills are automatically available when you use GitHub Copilot CLI:
+
+```bash
+# List available skills
+gh copilot skills list
+
+# Use a specific skill
+Use the /discover-standards skill to identify patterns in src/api/
+```
+
 ### In GitHub Copilot Chat
 
 Reference skills directly in your conversation:
 
 ```
-@github Use the discover-standards skill to identify API patterns in src/api/
+@github Use the /discover-standards skill to identify API patterns in src/api/
 ```
 
 ### In Workflow Files
@@ -109,15 +121,23 @@ When installed, GitHub Copilot agent skills are placed in:
 
 ```
 .github/
-└── copilot/
-    └── agent-os/
-        ├── discover-standards.md
-        ├── inject-standards.md
-        ├── index-standards.md
-        ├── plan-product.md
-        └── shape-spec.md
+└── skills/
+    ├── discover-standards/
+    │   └── SKILL.md
+    ├── inject-standards/
+    │   └── SKILL.md
+    ├── index-standards/
+    │   └── SKILL.md
+    ├── plan-product/
+    │   └── SKILL.md
+    └── shape-spec/
+        └── SKILL.md
 ```
 
+Each skill is in its own directory with a `SKILL.md` file that contains:
+- YAML frontmatter with `name` and `description`
+- Detailed instructions for GitHub Copilot to follow
+
 ## Standards Directory
 
 Regardless of which AI agent you use, standards are stored in:
@@ -138,10 +158,12 @@ While the core functionality is the same, there are some differences in how skil
 
 | Feature | Claude Code | GitHub Copilot |
 |---------|-------------|----------------|
-| Command prefix | `/` | `@github` |
-| Location | `.claude/commands/` | `.github/copilot/` |
+| Command prefix | `/` | `/` (in CLI) |
+| Location | `.claude/commands/` | `.github/skills/` |
+| File name | `command-name.md` | `SKILL.md` |
+| Structure | Single file | Directory with SKILL.md |
+| Frontmatter | Not required | YAML with name & description |
 | Sub-agents | Claude sub-agents | GitHub Copilot sub-agents |
-| Skills format | Markdown commands | Agent skills |
 
 ## Benefits of GitHub Copilot Integration
 
diff --git a/commands/github-copilot/discover-standards.md b/commands/github-copilot/discover-standards/SKILL.md
similarity index 91%
rename from commands/github-copilot/discover-standards.md
rename to commands/github-copilot/discover-standards/SKILL.md
index 8b310df7..79a235fb 100644
--- a/commands/github-copilot/discover-standards.md
+++ b/commands/github-copilot/discover-standards/SKILL.md
@@ -1,8 +1,6 @@
-# GitHub Copilot Agent Skill
-
-This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
-https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
-
+---
+name: discover-standards
+description: Extract tribal knowledge and patterns from your codebase into concise, documented standards. Use this when asked to identify or document coding patterns, conventions, and best practices from the codebase.
 ---
 
 # Discover Standards
@@ -11,14 +9,6 @@ Extract tribal knowledge from your codebase into concise, documented standards.
 
 This skill helps you identify and document patterns, conventions, and tribal knowledge from your codebase that should be captured as standards.
 
-## GitHub Copilot Skills Integration
-
-This skill leverages GitHub Copilot's ability to:
-- Analyze codebases across multiple files
-- Identify patterns and conventions
-- Ask clarifying questions using interactive prompts
-- Create and organize documentation files
-
 ## Important Guidelines
 
 - **Ask questions interactively** — Present options the user can confirm, choose between, or correct
@@ -218,5 +208,3 @@ When processing large codebases or complex analysis, consider using GitHub Copil
 - Analyze different areas of the codebase in parallel
 - Deep-dive into specific patterns or conventions
 - Generate draft standards for review
-
-Refer to [GitHub Copilot Agent Skills documentation](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills) for more details on creating and using sub-agents.
diff --git a/commands/github-copilot/index-standards.md b/commands/github-copilot/index-standards/SKILL.md
similarity index 94%
rename from commands/github-copilot/index-standards.md
rename to commands/github-copilot/index-standards/SKILL.md
index 51534e2d..c6ddeb64 100644
--- a/commands/github-copilot/index-standards.md
+++ b/commands/github-copilot/index-standards/SKILL.md
@@ -1,10 +1,7 @@
-# GitHub Copilot Agent Skill
-
-This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
-https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
-
 ---
-
+name: index-standards
+description: Rebuild and maintain the standards index file (index.yml) to enable quick discovery of relevant standards. Use this after creating or modifying standards files.
+---
 # Index Standards
 
 Rebuild and maintain the standards index file (`index.yml`).
diff --git a/commands/github-copilot/inject-standards.md b/commands/github-copilot/inject-standards/SKILL.md
similarity index 97%
rename from commands/github-copilot/inject-standards.md
rename to commands/github-copilot/inject-standards/SKILL.md
index 97d86c89..93369cbc 100644
--- a/commands/github-copilot/inject-standards.md
+++ b/commands/github-copilot/inject-standards/SKILL.md
@@ -1,10 +1,7 @@
-# GitHub Copilot Agent Skill
-
-This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
-https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
-
 ---
-
+name: inject-standards
+description: Inject relevant standards into the current context based on what you're working on. Use this when implementing code to ensure adherence to project patterns and conventions.
+---
 # Inject Standards
 
 Inject relevant standards into the current context, formatted appropriately for the situation.
diff --git a/commands/github-copilot/plan-product.md b/commands/github-copilot/plan-product/SKILL.md
similarity index 95%
rename from commands/github-copilot/plan-product.md
rename to commands/github-copilot/plan-product/SKILL.md
index 518bbfe2..b98fda5e 100644
--- a/commands/github-copilot/plan-product.md
+++ b/commands/github-copilot/plan-product/SKILL.md
@@ -1,10 +1,7 @@
-# GitHub Copilot Agent Skill
-
-This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
-https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
-
 ---
-
+name: plan-product
+description: Establish foundational product documentation including mission, roadmap, and tech stack. Use this when starting a new project or formalizing product direction.
+---
 # Plan Product
 
 Establish foundational product documentation through an interactive conversation. Creates mission, roadmap, and tech stack files in `agent-os/product/`.
diff --git a/commands/github-copilot/shape-spec.md b/commands/github-copilot/shape-spec/SKILL.md
similarity index 96%
rename from commands/github-copilot/shape-spec.md
rename to commands/github-copilot/shape-spec/SKILL.md
index 760d5ca3..d63fe7d1 100644
--- a/commands/github-copilot/shape-spec.md
+++ b/commands/github-copilot/shape-spec/SKILL.md
@@ -1,10 +1,7 @@
-# GitHub Copilot Agent Skill
-
-This is a GitHub Copilot agent skill for Agent OS. For more information about GitHub Copilot agent skills, see:
-https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
-
 ---
-
+name: shape-spec
+description: Gather context and structure planning for significant work in plan mode. Use this to create well-scoped plans that consider standards and product mission.
+---
 # Shape Spec
 
 Gather context and structure planning for significant work. **Run this command while in plan mode.**
diff --git a/scripts/project-install.sh b/scripts/project-install.sh
index 44f05238..32ec58ef 100755
--- a/scripts/project-install.sh
+++ b/scripts/project-install.sh
@@ -448,25 +448,28 @@ install_commands() {
                 
             github-copilot)
                 local commands_source="$BASE_DIR/commands/github-copilot"
-                local commands_dest="$PROJECT_DIR/.github/copilot/agent-os"
+                local commands_dest="$PROJECT_DIR/.github/skills"
                 
                 if [[ ! -d "$commands_source" ]]; then
-                    print_warning "No GitHub Copilot commands found in base installation"
+                    print_warning "No GitHub Copilot skills found in base installation"
                     continue
                 fi
                 
                 ensure_dir "$commands_dest"
                 
                 local count=0
-                for file in "$commands_source"/*.md; do
-                    if [[ -f "$file" ]]; then
-                        cp "$file" "$commands_dest/"
+                # Copy each skill directory
+                for skill_dir in "$commands_source"/*; do
+                    if [[ -d "$skill_dir" ]]; then
+                        local skill_name=$(basename "$skill_dir")
+                        # Copy the entire skill directory
+                        cp -r "$skill_dir" "$commands_dest/"
                         count=$((count + 1))
                     fi
                 done
                 
                 if [[ "$count" -gt 0 ]]; then
-                    print_success "Installed $count GitHub Copilot agent skills to .github/copilot/agent-os/"
+                    print_success "Installed $count GitHub Copilot skills to .github/skills/"
                     installed_count=$((installed_count + count))
                 fi
                 ;;

From 9f925860b219ef976e1ef8a4d5862a4e731bef2c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:13:40 +0000
Subject: [PATCH 6/9] Fix documentation inconsistencies in GitHub Copilot usage
 examples

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 GITHUB_COPILOT.md                                 | 14 ++++++++++++--
 commands/github-copilot/inject-standards/SKILL.md |  2 +-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/GITHUB_COPILOT.md b/GITHUB_COPILOT.md
index 9540beea..8b17e392 100644
--- a/GITHUB_COPILOT.md
+++ b/GITHUB_COPILOT.md
@@ -94,12 +94,22 @@ Use the /discover-standards skill to identify patterns in src/api/
 
 ### In GitHub Copilot Chat
 
-Reference skills directly in your conversation:
+Reference skills directly in your chat conversation:
 
 ```
 @github Use the /discover-standards skill to identify API patterns in src/api/
 ```
 
+### In GitHub Copilot CLI
+
+Skills are automatically loaded and can be invoked with the skill name:
+
+```bash
+# Skills will be available based on context
+# GitHub Copilot will suggest relevant skills automatically
+Use /discover-standards to identify patterns in src/api/
+```
+
 ### In Workflow Files
 
 Skills can be referenced in GitHub Actions or other CI/CD workflows that support GitHub Copilot integration.
@@ -109,7 +119,7 @@ Skills can be referenced in GitHub Actions or other CI/CD workflows that support
 GitHub Copilot skills support sub-agents for parallel execution:
 
 ```
-@github Use discover-standards skill with sub-agents to analyze:
+Use the discover-standards skill with sub-agents to analyze:
 1. API patterns in src/api/
 2. Database patterns in src/models/
 3. UI patterns in src/components/
diff --git a/commands/github-copilot/inject-standards/SKILL.md b/commands/github-copilot/inject-standards/SKILL.md
index 93369cbc..c0594074 100644
--- a/commands/github-copilot/inject-standards/SKILL.md
+++ b/commands/github-copilot/inject-standards/SKILL.md
@@ -233,7 +233,7 @@ These standards cover:
 
 ### Step 6: Surface Related Skills (Conversation scenario only)
 
-When in conversation scenario, check if `.claude/skills/` exists and contains related skills:
+When in conversation scenario, check if `.github/skills/` exists and contains related skills:
 
 ```
 Related Skills you might want to use:

From 853ac5087c222f52e85bfd6028bec846ea0c55a5 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:14:40 +0000
Subject: [PATCH 7/9] Remove duplicate GitHub Copilot CLI section from
 documentation

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 GITHUB_COPILOT.md | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/GITHUB_COPILOT.md b/GITHUB_COPILOT.md
index 8b17e392..301284e6 100644
--- a/GITHUB_COPILOT.md
+++ b/GITHUB_COPILOT.md
@@ -100,16 +100,6 @@ Reference skills directly in your chat conversation:
 @github Use the /discover-standards skill to identify API patterns in src/api/
 ```
 
-### In GitHub Copilot CLI
-
-Skills are automatically loaded and can be invoked with the skill name:
-
-```bash
-# Skills will be available based on context
-# GitHub Copilot will suggest relevant skills automatically
-Use /discover-standards to identify patterns in src/api/
-```
-
 ### In Workflow Files
 
 Skills can be referenced in GitHub Actions or other CI/CD workflows that support GitHub Copilot integration.

From 5e420238a80a06055c65991be4cf77fa28d25ad7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:50:01 +0000
Subject: [PATCH 8/9] Enhance GitHub Copilot discover-standards skill with
 explicit interactive instructions

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 .../discover-standards/SKILL.md               | 124 ++++++++++++++----
 1 file changed, 100 insertions(+), 24 deletions(-)

diff --git a/commands/github-copilot/discover-standards/SKILL.md b/commands/github-copilot/discover-standards/SKILL.md
index 79a235fb..8c62de55 100644
--- a/commands/github-copilot/discover-standards/SKILL.md
+++ b/commands/github-copilot/discover-standards/SKILL.md
@@ -11,14 +11,18 @@ This skill helps you identify and document patterns, conventions, and tribal kno
 
 ## Important Guidelines
 
-- **Ask questions interactively** — Present options the user can confirm, choose between, or correct
+- **Ask questions interactively** — Always prompt the user for input before proceeding to the next step. Present options the user can confirm, choose between, or correct
 - **Write concise standards** — Use minimal words. Standards must be scannable by AI agents without bloating context windows.
 - **Offer suggestions** — Don't make users think harder than necessary.
+- **Be thorough** — Analyze multiple areas of the codebase and create organized folder structures (e.g., api/, backend/, frontend/, components/)
+- **Process iteratively** — Work through one area at a time, then offer to continue with another area
 
 ## Process
 
 ### Step 1: Determine Focus Area
 
+**IMPORTANT:** Always prompt the user before making assumptions.
+
 Check if the user specified an area when running this command. If they did, skip to Step 2.
 
 If no area was specified:
@@ -28,7 +32,7 @@ If no area was specified:
    - **Frontend areas:** UI components, styling/CSS, state management, forms, routing
    - **Backend areas:** API routes, database/models, authentication, background jobs
    - **Cross-cutting:** Error handling, validation, testing, naming conventions, file structure
-3. Present the areas to the user:
+3. **Ask the user to select an area:**
 
 ```
 I've identified these areas in your codebase:
@@ -41,20 +45,20 @@ I've identified these areas in your codebase:
 Which area should we focus on for discovering standards? (Pick one, or suggest a different area)
 ```
 
-Wait for user response before proceeding.
+**Wait for user response before proceeding to Step 2.**
 
 ### Step 2: Analyze & Present Findings
 
 Once an area is determined:
 
-1. Read key files in that area (5-10 representative files)
-2. Look for patterns that are:
+1. **Read key files** in that area (5-10 representative files)
+2. **Look for patterns** that are:
    - **Unusual or unconventional** — Not standard framework/library patterns
    - **Opinionated** — Specific choices that could have gone differently
    - **Tribal** — Things a new developer wouldn't know without being told
    - **Consistent** — Patterns repeated across multiple files
 
-3. Present findings and let user select:
+3. **Present findings and ask user to select:**
 
 ```
 I analyzed [area] and found these potential standards worth documenting:
@@ -72,7 +76,7 @@ Options:
 - "Skip this area"
 ```
 
-Wait for user selection before proceeding.
+**Wait for user selection before proceeding to Step 3.**
 
 ### Step 3: Ask Why, Then Draft Each Standard
 
@@ -81,7 +85,7 @@ Wait for user selection before proceeding.
 1. **Ask 1-2 clarifying questions** about the "why" behind the pattern
 2. **Wait for user response**
 3. **Draft the standard** incorporating their answer
-4. **Confirm with user** before creating the file
+4. **Ask user to confirm** before creating the file
 5. **Create the file** if approved
 
 Example questions to ask (adapt based on the specific standard):
@@ -92,16 +96,26 @@ Example questions to ask (adapt based on the specific standard):
 
 **Do NOT batch all questions upfront.** Process one standard at a time through the full loop.
 
+**Do NOT skip the questioning step.** Understanding the "why" is critical for creating useful standards.
+
 ### Step 4: Create the Standard File
 
 For each standard (after completing Step 3's Q&A):
 
-1. Determine the appropriate folder (create if needed):
-   - `api/`, `database/`, `javascript/`, `css/`, `backend/`, `testing/`, `global/`
+1. **Determine the appropriate folder** (create if needed):
+   - `api/` — API endpoints, request/response formats, authentication
+   - `backend/` — Server-side patterns, business logic, data processing
+   - `frontend/` — UI patterns, state management, routing
+   - `components/` — Reusable UI components, component structure
+   - `database/` — Schema design, queries, migrations, data models
+   - `testing/` — Test patterns, mocking, coverage
+   - `global/` — Cross-cutting concerns, naming conventions, file structure
+   
+   **Create subdirectories to organize standards by domain.** Don't put all standards in the root.
 
 2. Check if a related standard file already exists — append to it if so
 
-3. Draft the content and confirm with user:
+3. **Draft the content and ask user to confirm:**
 
 ```
 Here's the draft for api/response-format.md:
@@ -124,15 +138,15 @@ All API responses use this envelope:
 Create this file? (yes / edit: [your changes] / skip)
 ```
 
-4. Create or update the file in `agent-os/standards/[folder]/`
+4. Create or update the file in `agent-os/standards/[folder]/[standard-name].md`
 5. **Then repeat Steps 3-4 for the next selected standard**
 
 ### Step 5: Update the Index
 
-After all standards are created:
+**CRITICAL:** After all standards for the current area are created, you MUST update the index file.
 
 1. Scan `agent-os/standards/` for all `.md` files
-2. For each new file without an index entry, ask user:
+2. For each new file without an index entry, **ask user to confirm description:**
 
 ```
 New standard needs an index entry:
@@ -143,32 +157,60 @@ Suggested description: "API response envelope structure and error format"
 Accept this description? (yes / or type a better one)
 ```
 
-3. Update `agent-os/standards/index.yml`:
+3. **Create or update `agent-os/standards/index.yml`:**
 
 ```yaml
 api:
   response-format:
     description: API response envelope structure and error format
+  error-codes:
+    description: Custom error code patterns for API responses
+
+backend:
+  data-validation:
+    description: Input validation and sanitization patterns
 ```
 
-Alphabetize by folder, then by filename.
+**Alphabetize entries by folder name, then by filename within each folder.**
+
+4. If `index.yml` doesn't exist, create it with proper YAML structure
 
 ### Step 6: Offer to Continue
 
-Ask the user:
+**IMPORTANT:** After completing standards for one area, always offer to continue with another area.
+
+**Ask the user:**
 
 ```
 Standards created for [area]:
 - api/response-format.md
 - api/error-codes.md
 
-Would you like to discover standards in another area, or are we done?
+I can discover standards in other areas of your codebase. Would you like to:
+1. Continue discovering standards in another area
+2. Finish for now
+
+What would you like to do?
 ```
 
+If the user chooses to continue:
+- Return to Step 1 with remaining areas
+- Process the next area through all steps
+- Keep iterating until the user is satisfied or all major areas are covered
+
+**The goal is comprehensive coverage across multiple domains (api, backend, frontend, components, etc.), not just a single area.**
+
 ## Output Location
 
-All standards: `agent-os/standards/[folder]/[standard].md`
-Index file: `agent-os/standards/index.yml`
+**All standards:** `agent-os/standards/[folder]/[standard-name].md`
+**Index file:** `agent-os/standards/index.yml`
+
+### Critical Requirements
+
+1. **Always create the index.yml file** — This file is required for the `/inject-standards` skill to work properly
+2. **Organize into folders** — Create subdirectories like `api/`, `backend/`, `frontend/`, `components/` to keep standards organized
+3. **Be thorough** — Aim to create multiple standards across multiple areas, not just 1-2 files
+4. **Update index after each area** — Don't wait until the end; update index.yml after completing each area's standards
 
 ## Writing Concise Standards
 
@@ -204,7 +246,41 @@ When an error occurs in our application, we have established a consistent patter
 
 ## GitHub Copilot Sub-Agent Usage
 
-When processing large codebases or complex analysis, consider using GitHub Copilot sub-agents to:
-- Analyze different areas of the codebase in parallel
-- Deep-dive into specific patterns or conventions
-- Generate draft standards for review
+When processing large codebases or when the user wants comprehensive analysis:
+
+1. **Suggest using sub-agents** to analyze different areas in parallel:
+   ```
+   I can use sub-agents to analyze multiple areas simultaneously:
+   - Sub-agent 1: Analyze API patterns
+   - Sub-agent 2: Analyze frontend components  
+   - Sub-agent 3: Analyze backend services
+   
+   This will be faster. Would you like me to do this?
+   ```
+
+2. **Coordinate sub-agent findings** by collecting their results and presenting a unified list of standards to document
+
+3. **Still follow the interactive process** even when using sub-agents — ask the user for confirmation and clarification at each step
+
+## Example Complete Workflow
+
+Here's what a successful session should look like:
+
+1. **User:** "Discover standards in my codebase"
+2. **Agent:** Analyzes codebase, identifies 5 areas (API, Backend, Frontend, Database, Testing)
+3. **Agent:** Asks user which area to start with
+4. **User:** "Let's start with API"
+5. **Agent:** Analyzes API code, finds 8 potential standards, asks user which to document
+6. **User:** "All of them"
+7. **Agent:** For each standard:
+   - Asks why questions
+   - Drafts standard
+   - Asks for confirmation
+   - Creates file in `agent-os/standards/api/[standard-name].md`
+8. **Agent:** Updates `agent-os/standards/index.yml` with all 8 standards
+9. **Agent:** "Created 8 API standards. Continue with another area?"
+10. **User:** "Yes, do Backend next"
+11. **Agent:** Repeats process for Backend area
+12. ... continues until user is satisfied
+
+**Final result:** 20-30+ standards organized across multiple folders (api/, backend/, frontend/, database/, testing/) with a complete index.yml file.

From 33f3897abe26e19f81f0a02a634286d9fd582002 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:51:02 +0000
Subject: [PATCH 9/9] Fix terminology in example workflow to use 'GitHub
 Copilot' instead of 'Agent'

Co-authored-by: EverybodyKurts <879734+EverybodyKurts@users.noreply.github.com>
---
 .../github-copilot/discover-standards/SKILL.md     | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/commands/github-copilot/discover-standards/SKILL.md b/commands/github-copilot/discover-standards/SKILL.md
index 8c62de55..8849f066 100644
--- a/commands/github-copilot/discover-standards/SKILL.md
+++ b/commands/github-copilot/discover-standards/SKILL.md
@@ -267,20 +267,20 @@ When processing large codebases or when the user wants comprehensive analysis:
 Here's what a successful session should look like:
 
 1. **User:** "Discover standards in my codebase"
-2. **Agent:** Analyzes codebase, identifies 5 areas (API, Backend, Frontend, Database, Testing)
-3. **Agent:** Asks user which area to start with
+2. **GitHub Copilot:** Analyzes codebase, identifies 5 areas (API, Backend, Frontend, Database, Testing)
+3. **GitHub Copilot:** Asks user which area to start with
 4. **User:** "Let's start with API"
-5. **Agent:** Analyzes API code, finds 8 potential standards, asks user which to document
+5. **GitHub Copilot:** Analyzes API code, finds 8 potential standards, asks user which to document
 6. **User:** "All of them"
-7. **Agent:** For each standard:
+7. **GitHub Copilot:** For each standard:
    - Asks why questions
    - Drafts standard
    - Asks for confirmation
    - Creates file in `agent-os/standards/api/[standard-name].md`
-8. **Agent:** Updates `agent-os/standards/index.yml` with all 8 standards
-9. **Agent:** "Created 8 API standards. Continue with another area?"
+8. **GitHub Copilot:** Updates `agent-os/standards/index.yml` with all 8 standards
+9. **GitHub Copilot:** "Created 8 API standards. Continue with another area?"
 10. **User:** "Yes, do Backend next"
-11. **Agent:** Repeats process for Backend area
+11. **GitHub Copilot:** Repeats process for Backend area
 12. ... continues until user is satisfied
 
 **Final result:** 20-30+ standards organized across multiple folders (api/, backend/, frontend/, database/, testing/) with a complete index.yml file.