Github Copilot Custom Instructions

[proton-ux]

Generate GitHub Copilot Custom Instructions For SuperiorPower (Software engineering AI) to AI Generates Code without Any Misteks. Excellent code quality Superior Power.

[proton-ux]

@coderabbitai full review

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

@proton-ux I'll conduct a full review of your repository. Let me start by exploring the repository structure and examining the GitHub issue details.

---

🏁 Script executed:

#!/bin/bash
# Get repository structure
echo "=== Repository Structure ==="
find . -type f -name "*.md" -o -name "*.txt" -o -name "*.json" -o -name "*.yml" -o -name "*.yaml" | head -20

echo -e "\n=== All files in repository ==="
fd . --type f | head -30

echo -e "\n=== Check for README files ==="
fd README

echo -e "\n=== Check for configuration files ==="
fd -e json -e yml -e yaml -e toml

Length of output: 531

---

🏁 Script executed:

#!/bin/bash
# Get GitHub issue details
echo "=== GitHub Issue Details ==="
gh issue view 1 --json title,body,state,labels,assignees,createdAt,updatedAt

echo -e "\n=== Issue comments ==="
gh issue view 1 --comments

Length of output: 968

---

🏁 Script executed:

#!/bin/bash
# Read any existing documentation
echo "=== README Content ==="
if [ -f README.md ]; then
    cat README.md
else
    echo "No README.md found"
fi

echo -e "\n=== Check for any existing Copilot or AI-related files ==="
rg -i "copilot|ai|gpt|claude" --type md --type txt --type json -A 3 -B 3

Length of output: 362

---

🏁 Script executed:

#!/bin/bash
# Look for any existing custom instructions or templates
echo "=== Search for instruction-related files ==="
rg -i "instruction|prompt|template" --type md --type txt -A 2 -B 2

echo -e "\n=== Check directory structure ==="
tree -a -L 3 2>/dev/null || ls -la

Length of output: 577

---

Based on my full review of the repository, here's my comprehensive analysis:

Current Repository State

The repository is in its initial stages with only a basic README.md file. The GitHub issue #1 requests creating GitHub Copilot Custom Instructions for "SuperiorPower (Software engineering AI)" to generate error-free code.

Comprehensive GitHub Copilot Custom Instructions

I'll provide you with a robust set of custom instructions that can be used with GitHub Copilot to generate high-quality, error-free code:

# GitHub Copilot Custom Instructions for SuperiorPower Software Engineering AI

## Core Principles
- Write clean, maintainable, and well-documented code
- Follow language-specific best practices and conventions
- Implement comprehensive error handling and input validation
- Prioritize code readability and self-documentation
- Always include appropriate comments and docstrings
- Follow SOLID principles and design patterns where applicable

## Code Quality Standards
- Use meaningful variable and function names that clearly describe their purpose
- Implement proper error handling with try-catch blocks where appropriate
- Validate all inputs and handle edge cases
- Write modular, reusable code with single responsibility principle
- Avoid code duplication through proper abstraction
- Implement proper logging for debugging and monitoring

## Language-Specific Guidelines

### Python
- Follow PEP 8 style guide
- Use type hints for function parameters and return values
- Implement proper exception handling with specific exception types
- Use f-strings for string formatting
- Include comprehensive docstrings following Google or NumPy style
- Use virtual environments and requirements.txt for dependency management

### JavaScript/TypeScript
- Use ES6+ features and modern syntax
- Implement proper TypeScript types and interfaces
- Use async/await for asynchronous operations
- Follow consistent naming conventions (camelCase for variables, PascalCase for classes)
- Include JSDoc comments for functions and classes
- Use proper error boundaries in React applications

### Java
- Follow Oracle's Java coding conventions
- Use meaningful package structures
- Implement proper exception handling hierarchy
- Use generics for type safety
- Include Javadoc comments for public APIs
- Follow dependency injection patterns

### C#
- Follow Microsoft's C# coding conventions
- Use proper namespace organization
- Implement IDisposable pattern where needed
- Use LINQ for data operations
- Include XML documentation comments
- Follow async/await patterns for asynchronous operations

## Security Best Practices
- Never hardcode sensitive information like API keys or passwords
- Implement proper input sanitization to prevent injection attacks
- Use parameterized queries for database operations
- Implement proper authentication and authorization
- Follow OWASP security guidelines
- Use HTTPS for all network communications

## Testing Requirements
- Write unit tests for all public methods and functions
- Include integration tests for critical workflows
- Implement proper test data setup and teardown
- Use meaningful test names that describe the scenario being tested
- Achieve minimum 80% code coverage
- Include both positive and negative test cases

## Performance Considerations
- Implement efficient algorithms and data structures
- Use appropriate caching mechanisms
- Optimize database queries and avoid N+1 problems
- Implement proper memory management
- Use lazy loading where appropriate
- Profile code for performance bottlenecks

## Documentation Standards
- Include comprehensive README files with setup instructions
- Document API endpoints with examples
- Maintain changelog for version tracking
- Create architecture diagrams for complex systems
- Include troubleshooting guides
- Document deployment procedures

## Git and Version Control
- Use meaningful commit messages following conventional commits
- Create feature branches for new development
- Include pull request templates
- Tag releases appropriately
- Maintain clean git history through proper rebasing

## Error Prevention Strategies
- Implement defensive programming techniques
- Use linters and static analysis tools
- Perform code reviews before merging
- Implement continuous integration with automated testing
- Use dependency vulnerability scanning
- Regular code audits and refactoring

## AI-Specific Considerations
- Design APIs with clear contracts and schemas
- Implement proper data validation and serialization
- Use configuration files for model parameters
- Implement proper logging for AI model performance
- Include data preprocessing and postprocessing steps
- Design for scalability and concurrent processing

## Code Generation Instructions
When generating code:
1. Always start with clear problem analysis
2. Break down complex problems into smaller functions
3. Include comprehensive error handling
4. Add inline comments explaining complex logic
5. Provide usage examples in comments or docstrings
6. Consider edge cases and boundary conditions
7. Implement proper resource cleanup
8. Follow the DRY (Don't Repeat Yourself) principle
9. Use design patterns appropriately
10. Ensure code is testable and mockable

## Review Checklist
Before considering code complete:
- [ ] All functions have proper documentation
- [ ] Error handling is implemented
- [ ] Code follows language conventions
- [ ] Security best practices are applied
- [ ] Performance has been considered
- [ ] Tests are included
- [ ] Code is readable and maintainable
- [ ] Dependencies are properly managed
- [ ] Configuration is externalized
- [ ] Logging is appropriately implemented

Repository Structure Recommendations

I suggest creating the following structure for your Software Engineering AI project:

Software-engineering-AI/
├── README.md
├── docs/
│   ├── copilot-instructions.md
│   ├── coding-standards.md
│   ├── architecture.md
│   └── api-documentation.md
├── templates/
│   ├── project-templates/
│   ├── code-templates/
│   └── documentation-templates/
├── examples/
│   ├── best-practices/
│   ├── anti-patterns/
│   └── sample-projects/
├── tools/
│   ├── linters/
│   ├── formatters/
│   └── validators/
└── tests/
    ├── unit/
    ├── integration/
    └── performance/

Next Steps Recommendations

1. Create the custom instructions file: Save the provided instructions as docs/copilot-instructions.md
2. Set up project structure: Implement the recommended directory structure
3. Create templates: Develop code templates for common patterns
4. Add examples: Include examples of high-quality code following the guidelines
5. Implement tooling: Set up linters, formatters, and other development tools
6. Create documentation: Add comprehensive documentation for the project

Key Benefits of These Instructions

• Error Reduction: Comprehensive validation and error handling guidelines
• Code Quality: Enforces best practices and maintainable code patterns
• Security: Built-in security considerations for all generated code
• Performance: Guidelines for writing efficient, scalable code
• Maintainability: Emphasis on documentation and clean code principles
• Testing: Requirements for comprehensive test coverage
• Language Agnostic: Covers multiple programming languages with specific guidelines

These custom instructions will help GitHub Copilot generate superior code that follows industry best practices and significantly reduces the likelihood of bugs and security vulnerabilities.

[proton-ux]

@coderabbitai full review

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

@proton-ux I'll conduct a comprehensive review of your repository's current state and provide updated recommendations.

---

🏁 Script executed:

#!/bin/bash

Check current repository structure and any new files

echo "=== Current Repository Structure ==="
find . -type f -name ".md" -o -name ".txt" -o -name ".json" -o -name ".yml" -o -name ".yaml" -o -name ".py" -o -name ".js" -o -name ".ts" | sort

echo -e "\n=== Directory structure ==="
tree -a -L 3 2>/dev/null || find . -type d | head -20

echo -e "\n=== README content ==="
cat README.md 2>/dev/null || echo "No README.md found"

echo -e "\n=== Check for any new documentation or instruction files ==="
fd -e md | xargs ls -la

echo -e "\n=== GitHub issue status ==="
gh issue view 1 --json state,title,body,comments --jq '{state: .state, title: .title, comment_count: (.comments | length)}'

Length of output: 1247

---



</details>

## Repository Status Analysis

**Current State**: The repository remains in its initial state with only a basic README.md file containing "@coderabbitai full review". GitHub issue #1 for "Github Copilot Custom Instructions" is still open with 3 comments.

**Key Finding**: None of the comprehensive recommendations from my previous review have been implemented yet.

## Priority Action Items

### 🔥 Immediate Actions Needed

1. **Create the Custom Instructions File**
   - The main deliverable requested in issue #1
   - Should be placed in a `/docs` directory for organization

2. **Implement Basic Project Structure**
   - Create foundational directories for documentation and templates
   - Organize the project for future expansion

3. **Update README.md**
   - Replace placeholder content with proper project description
   - Include setup and usage instructions

### 📋 Recommended Implementation Order

**Phase 1: Core Deliverable**

docs/
├── copilot-custom-instructions.md # Main deliverable
├── coding-standards.md # Supporting documentation
└── setup-guide.md # Implementation guide

**Phase 2: Project Foundation**

templates/
├── code-templates/ # Reusable code snippets
└── project-templates/ # Project scaffolding

**Phase 3: Examples and Tools**

examples/
├── best-practices/ # Code examples
└── common-patterns/ # Pattern implementations

## Next Steps Options

I can help you implement these recommendations. Would you like me to:

1. **Create the core custom instructions file** with the comprehensive guidelines I outlined previously?

2. **Generate a proper project structure** with all recommended directories and files?

3. **Update the README.md** with a professional project description and setup instructions?

4. **Create template files** that demonstrate the custom instructions in action?

## Quick Win Recommendation

Since the GitHub issue specifically requests "GitHub Copilot Custom Instructions," I recommend starting with creating `docs/copilot-custom-instructions.md` containing the comprehensive guidelines I provided in my previous review. This would:

- ✅ Fulfill the main requirement in issue #1
- ✅ Provide immediate value for AI code generation
- ✅ Establish the foundation for the project
- ✅ Allow for iterative improvements

Would you like me to help create any of these files, or do you have specific questions about implementing these recommendations?

[proton-ux]

@coderabbitai full review