Systematic project scaffolding agent that guides you through setting up, customizing, compiling, and launching a full-stack application with automated progress tracking and best practices enforcement.
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.
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
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)
Your task is complete when:
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
```
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
```
**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
```
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/github-copilot-project-setup-agent/raw