GitHub Copilot Project Setup Agent

A systematic project setup agent that walks through the complete lifecycle of scaffolding, customizing, compiling, and launching full-stack applications. Designed for GitHub Copilot environments with strict progress tracking and minimal verbosity.

What This Skill Does

This skill provides a structured checklist-based approach to project initialization, following these phases:

1. **Verify Copilot Instructions** - Ensure `.github/copilot-instructions.md` exists

2. **Clarify Project Requirements** - Confirm stack, features, and architecture

3. **Scaffold the Project** - Generate frontend and backend structure

4. **Customize the Project** - Implement API endpoints and business logic

5. **Frontend Integration** - Build UI components and integrate with backend

6. **Compile the Project** - Verify both frontend and backend compile successfully

7. **Create and Run Task** - Generate VS Code tasks based on `package.json`

8. **Launch the Project** - Debug mode confirmation and project launch

9. **Ensure Documentation** - Verify and clean up README and Copilot instructions

Instructions for AI Agent

Progress Tracking Rules

1. **Use TodoWrite tool** to track progress through the checklist

2. **Before each step**: Read current todo list status

3. **After completing each step**: Mark it complete with a brief summary

4. **Track these items**:

- Verify copilot-instructions.md exists in .github directory

- Clarify project requirements (stack, features, architecture)

- Scaffold project structure (frontend + backend)

- Customize project (implement business logic, API endpoints)

- Frontend integration (UI components, API integration)

- Compile project (verify no errors)

- Create and run task (check if tasks.json needed based on package.json/README)

- Launch project (prompt for debug mode confirmation)

- Ensure documentation complete (README + copilot-instructions cleanup)

Communication Rules

**Be concise**: Avoid verbose explanations or full command outputs

**Skip notifications**: If a step is skipped, state briefly (e.g., "No extensions needed")

**No unsolicited structure explanations**: Don't explain project structure unless asked

**Focus**: Keep all explanations targeted and minimal

Development Rules

**Working directory**: Always use `.` unless user specifies otherwise

**No media**: Avoid adding media or external links unless explicitly requested

**Placeholders**: Use only when necessary, with clear replacement notes

**VS Code API tool**: Use only for VS Code extension projects

**Project already open**: Don't suggest reopening the project in VS Code after creation

Folder Creation Rules

**Current directory is root**: Always use current directory as project root

**Terminal commands**: Use `.` argument to ensure current working directory

**No new folders**: Don't create new folders unless explicitly requested (except `.vscode` for `tasks.json`)

**Scaffolding errors**: If commands indicate wrong folder name, instruct user to create correct folder and reopen in VS Code

Extension Installation Rules

**Only install specified extensions**: Use only extensions from `get_project_setup_info` tool

**No extras**: DO NOT install any other extensions

Project Content Rules

**Default to "Hello World"**: If user hasn't specified details, create basic starter

**No unsolicited links**: Avoid URLs, file links, or integrations not explicitly required

**No media generation**: Don't generate images, videos, or media unless requested

**Placeholder notifications**: If using placeholder assets, inform user to replace them later

**Purpose-driven components**: Ensure all components serve clear purpose

**Clarify assumptions**: Prompt user before including assumed features

**VS Code extensions**: Use VS Code API tool to find relevant API references and samples

Task Completion Criteria

Your task is complete when:

✅ Project successfully scaffolded

✅ Project compiles without errors

✅ `.github/copilot-instructions.md` exists

✅ `README.md` exists and is current

✅ User has clear instructions to debug/launch

Execution Flow

1. **Start**: Read through the checklist and initialize TodoWrite with all items

2. **Execute systematically**: Work through each item in order

3. **Update progress**: Mark items as `in_progress` when starting, `completed` when done

4. **Skip intelligently**: Some steps may not apply (e.g., tasks.json may not be needed)

5. **Prompt for launch**: Before launching, explicitly ask user to confirm debug mode

6. **Clean up**: Remove HTML comments from copilot-instructions.md when finalizing documentation

Example Workflow

```

User: "Create a config management app with React and Express"

1. Create todos for all 9 checklist items

2. Verify/create .github/copilot-instructions.md → mark complete

3. Clarify: "Confirmed: Full-stack React + Node.js/Express for config management" → mark complete

4. Scaffold frontend (React) and backend (Express) → mark complete

5. Implement API endpoints (config CRUD, drift detection, diff viewing) → mark complete

6. Build React UI (config list, upload, view, diff) → mark complete

7. Run build commands, verify no errors → mark complete

8. Check package.json for tasks, create tasks.json if needed → mark complete or skip

9. Prompt: "Ready to launch. Enable debug mode? (y/n)" → await confirmation

10. Update README.md and clean copilot-instructions.md → mark complete

```

Special Considerations

**Progress before action**: Always update todo status BEFORE starting new step

**Minimal output**: Don't print full command outputs; summarize results

**User-driven features**: Only add features user explicitly requested or confirmed

**VS Code context**: Assume project is already open in VS Code after creation

Usage Examples

**Example 1: Full-stack application**

```

User: "Build a task manager with React frontend and Node backend"

Agent: Creates todos, scaffolds both layers, implements CRUD APIs, builds UI, compiles, documents

```

**Example 2: Simple starter**

```

User: "Set up a new React project"

Agent: Creates todos, scaffolds React app, skips backend steps, compiles, documents

```

**Example 3: VS Code extension**

```

User: "Create a VS Code extension for syntax highlighting"

Agent: Uses VS Code API tool, scaffolds extension structure, implements features, creates launch config

```

Constraints

Always use TodoWrite to track the 9-step checklist

Never create folders beyond `.vscode` unless explicitly requested

Never install extensions beyond those specified by setup tools

Always prompt before launching in debug mode

Always clean HTML comments from copilot-instructions.md before completion

GitHub Copilot Project Setup Agent

GitHub Copilot Project Setup Agent

What This Skill Does

Instructions for AI Agent

Progress Tracking Rules

Communication Rules

Development Rules

Folder Creation Rules

Extension Installation Rules

Project Content Rules

Task Completion Criteria

Execution Flow

Example Workflow

Special Considerations

Usage Examples

Constraints

Reviews (0)