A curated collection of custom agents, skills, rules, and prompts. Originally for GitHub Copilot, this collection now fully supports OpenCode, Google Antigravity, CommandCode, ChatGPT Codex, Pi Dev Coding Agent, and Oh My Pi (omp), specifically tailored for Indonesian developers and development workflows. The custom agents and SDLC workflows are heavily inspired by the GitHub Spec Kit, with additional enhancements and refinements.
This repository provides a comprehensive set of tools to enhance your AI-assisted development experience, including:
- 🤖 Custom Agents: Specialized AI agents for different development scenarios (PRD, Specification, Planning, Coding, Review).
- 🤹 Skills: Specialized capabilities paired with agents for advanced autonomous workflows.
- 📝 Rules & Instructions: Best practices and coding guidelines for various languages and frameworks.
- 🔑 BYOK Copilot Config: Ready-to-use
chatLanguageModels.jsontemplate for bringing your own API keys to VS Code Copilot chat. - 🔌 Multi-Platform: Ready-to-use configurations for OpenCode (
.opencode), Google Antigravity (.agents), Claude Code (.claude), GitHub Copilot (.github), CommandCode (.commandcode), ChatGPT Codex (.codex), Pi Dev Coding Agent (.pi), and Oh My Pi (.omp).
- Overview
- Getting Started
- Custom Agents
- Skills
- Workflow & Methodology
- Supplementary Skills
- BYOK Copilot Config
- Advanced Customization Guide
- Contributing
- Resources
- Support
- License
- An AI Assistant platform of your choice:
Choose either the Automated (recommended) or Manual installation method:
Run the following command in your terminal inside your project root directory:
- Linux / macOS (Bash/Zsh):
curl -fsSL https://raw.githubusercontent.com/GulajavaMinistudio/awesome-copilot-id/main/install.sh | bash - Windows Terminal (PowerShell):
irm https://raw.githubusercontent.com/GulajavaMinistudio/awesome-copilot-id/main/install.ps1 | iex
The interactive script will download the repository, prompt you to choose your platform configuration, copy the files, and safely handle existing configuration files (such as memory.instructions.md and AGENTS.md) by offering options to keep, replace, or merge them.
-
Clone this repository:
git clone https://github.com/GulajavaMinistudio/awesome-copilot-id.git
-
Choose your platform configuration:
- For CommandCode: Copy the
.commandcodedirectory to your project root. - For OpenCode: Copy the
.opencodedirectory fromopencode-configuration/to your project root. - For Google Antigravity: Copy the
.agentsdirectory to your project root. - For GitHub Copilot: Copy the
.githubdirectory to your project root. - For ChatGPT Codex: Copy the
.codexdirectory to your project root. - For Claude Code: Copy the
.claudedirectory to your project root. - For Pi Dev Coding Agent: Copy the
.pidirectory to your project root. - For Oh My Pi (
omp): Copy the.ompdirectory to your project root.
[!IMPORTANT] Don't copy everything! Only select the agents, skills, or rules that match your development needs.
- For CommandCode: Copy the
-
Mandatory Step: Copy the
AGENTS.mdfile to the root of your project. This file contains the core SDLC rules, directives, and interaction philosophy that all agents must follow to ensure consistency.cp awesome-copilot-id/AGENTS.md ./
[!IMPORTANT] After copying
AGENTS.md, you must open it and update the first line (# AGENTS.md - [Your Application Name]) to match your actual project's context. This helps the AI agents understand the specific project they are working on. -
Example manual installation for specific agents and skills:
# Create directories based on your platform (e.g., Google Antigravity) mkdir -p .agents/rules .agents/skills # Copy specific agents cp awesome-copilot-id/.agents/rules/GodModeDev.md .agents/rules/ # Copy specific skills cp -r awesome-copilot-id/.agents/skills/karpathy-guidelines .agents/skills/
-
Restart your IDE or AI assistant to apply the changes.
Tip
You can also reference these files from a central location in your system and symlink them to your projects for easier management.
Custom agents are specialized AI assistants for specific development roles and tasks. Each agent is paired with a specific skill to accomplish its phase in the development lifecycle. Place them in your platform's respective directory (.commandcode/agents/, .agents/rules/, .claude/agents/, .opencode/agents/, .github/agents/, .codex/agents/, .pi/agents/, or .omp/agents/).
Important
Don't forget to copy AGENTS.md to your project root after copying these agents. This file contains the core SDLC rules that all agents must follow. See Step #3 in Installation for details.
| Agent | Associated Skill | Description | Best For |
|---|---|---|---|
| @BrainstormingExplorerAnalyst | brainstorming-explorer |
Codebase exploration and architectural brainstorming | Phase 0 Discovery, exploring unfamiliar code, generating raw drafts |
| @ProductManagerPRD | product-manager-prd |
Product Requirement Document creation | Feature planning, writing user stories, and acceptance criteria |
| @ClarificationAnalyst | clarification-analyst |
Requirement interrogation | Finding ambiguities and missing edge cases in PRD/Specs/Plans |
| @SpecificationArchitect | specification-architect |
Technical specification creation | Writing detailed, machine-readable tech specs |
| @ArtifactConsistencyChecker | artifact-consistency-checker |
Consistency & traceability audit | Validating PRD vs Spec vs Plan to prevent scope creep |
| @PlannerArchitect | planner-architect |
Strategic planning & architecture | Generating formal, structured implementation plans |
| @GodModeDev | god-mode-dev (supp: karpathy-guidelines, omni-dev, ui-designer, fable-protocol, ponytail-lazy-senior-dev) |
God-Tier Autonomous Engineer | Coding, implementation, and surgical modifications |
| @ExpertCodeReviewer | expert-code-reviewer |
Code review and security audit | Clean Code/SOLID audits and refactoring plans |
| @BugRemediationArchitect | bug-remediation-architect |
Bug analysis and fixing | Root cause analysis and structured bug-fix plans |
| @DiataxisDocumentationArchitect | diataxis-documentation-architect |
Technical documentation specialist | Writing tutorials, how-to guides, and reference docs |
Depending on your platform (CommandCode, OpenCode, Antigravity, Copilot, ChatGPT Codex, Pi Dev, or Oh My Pi omp), you can usually invoke these agents via chat:
@GodModeDev implement the shopping cart based on the plan
@ExpertCodeReviewer review my service layer and suggest refactoring
@ProductManagerPRD create a PRD for the user authentication module
Skills provide agents with specialized capabilities, workflows, and prompts. They are located in the skills directory (e.g., .commandcode/skills, .agents/skills, .claude/skills, .opencode/skills, .codex/skills, .pi/skills, or .omp/skills).
Important
Don't forget to copy AGENTS.md to your project root after copying these skills. This file contains the core SDLC rules that all agents and skills must follow. See Step #3 in Installation for details.
| Skill | Description |
|---|---|
| project-researcher | Scans, analyzes, and documents the existing repository architecture, directories, and file purposes into docs/ARCHITECTURE.md |
| brainstorming-explorer | Systematic codebase exploration, architectural critique, and Project Discovery Draft generation |
| memory-manager | Standardized workflow for discovering, reading, writing, and compacting memory.instructions.md with a permanent Knowledge Base for cross-session decisions and fast-path discovery via AGENTS.md |
| karpathy-guidelines | Behavioral guidelines to reduce common LLM coding mistakes and encourage surgical modifications |
| ponytail-lazy-senior-dev | Applies the "lazy senior developer" mindset, prioritizing code reuse, minimalism, YAGNI principles, and root-cause fixes |
| omni-dev | Omni-expert principal software architect. Enforces clean code, clean architecture, deep reasoning, mandatory testing, and strict anti-ambiguity protocols |
| god-mode-dev | God-Tier Autonomous Engineer for Coding/Implementation (Phase 6), executing code strictly based on /spec/ and /plan/ |
| product-manager-prd | Workflow to generate comprehensive PRDs |
| clarification-analyst | Interrogates requirements for hidden assumptions and edge cases |
| grilling | Interrogates the user relentlessly about a plan or design to stress-test architecture before building |
| specification-architect | Generates detailed technical specs based on clarified requirements |
| ui-designer | Elite UI/UX Design Lead & Frontend Architect. Generates distinctive, non-templated interfaces with opinionated aesthetics, deliberate typography, and exact UX copy |
| artifact-consistency-checker | Validates traceability across documents to prevent missing coverage |
| planner-architect | Generates formal executable implementation plans |
| expert-code-reviewer | Code review and security audit against Clean Code principles |
| bug-remediation-architect | Workflow for tracing root causes and generating bug-fix strategies |
| diataxis-documentation-architect | Audits and writes structured documentation based on Diátaxis Framework |
| fable-protocol | An advanced, autonomous AI agent skill designed to execute complex, multi-step, and long-horizon tasks with high reliability and minimal human interruption |
Agent files use the .md or .agent.md extension depending on the platform, and feature a YAML frontmatter:
---
description: "God Mode Developer - God-Tier Autonomous Engineer with Deep Thinking Protocol."
mode: all
---Body: Instructions and guidelines for the agent behavior. You can:
- Define specialized instructions for the agent's role
- Specify core directives and interaction philosophies
- Detail how the agent should utilize its assigned skill
In our architecture, skills aren't just passive sets of tools or instructions; they have the power to dynamically transform your base AI assistant into a highly specialized agent persona.
If a skill contains a ## 🎭 Dynamic Persona Activation block in its SKILL.md file, merely invoking that skill will automatically override the default assistant's system prompt and transform it into the specialized agent assigned to that skill.
For example, directly executing the product-manager-prd skill will automatically activate the @ProductManagerPRD persona and its strict rules, meaning you don't necessarily have to @mention the custom agent manually!
To prevent context bleeding and scope creep, our SDLC agents enforce Strict Session Isolation. Once an agent persona (e.g., @SpecificationArchitect) is activated in a chat session, that session is locked to that persona.
However, we have Utility Skills that can be invoked at any time without triggering a session lock clash:
- Persona-Bound Skills: Contain a
## 🎭 Dynamic Persona Activationblock in theirSKILL.md. Invoking them locks the session. If you try to invoke a different persona-bound skill in the same session, the agent will reject it to maintain focus. - Utility Skills: Skills without the persona activation block (like
grilling,memory-manager, andfable-protocol). These can be invoked freely by any agent in the middle of a session. For example,@ClarificationAnalystcan invoke thegrillingskill to interrogate a document without losing its analyst persona.
Custom User Skills: Any custom skill you create or download that lacks the Dynamic Persona Activation block will automatically be treated as a Utility Skill and can be freely called at any time.
We adopt a strict and structured SDLC workflow, heavily inspired by the GitHub Spec Kit approach. Development must follow a sequential order, with no skipped phases:
- Discovery (Phase 0): Use
@BrainstormingExplorerAnalystto explore existing codebases, brainstorm architecture, and generate raw drafts for Product Managers. - PRD (Requirements): Use
@ProductManagerPRDto define user stories and acceptance criteria. - Clarification: Use
@ClarificationAnalystto interrogate the PRD to resolve ambiguities. - Spec (Technical Specification): Use
@SpecificationArchitectto generate machine-readable technical specs. - Spec Clarification: Use
@ClarificationAnalystto interrogate the technical specification. - Consistency Check: Use
@ArtifactConsistencyCheckerto validate traceability across PRD and Spec. - Plan (Implementation Planning): Use
@PlannerArchitectto generate executable implementation plans. - Plan Clarification: Use
@ClarificationAnalystto interrogate the implementation plan. - Code (Implementation): Use
@GodModeDevfor coding, ensuring strict testing (unit/widget/integration) after every phase. - Review: Use
@ExpertCodeReviewerfor code review and security audits. (For bug fixes, use@BugRemediationArchitect) - Docs: Use
@DiataxisDocumentationArchitectfor user documentation.
Important
- Complete and structured documentation must exist before coding begins.
- Every output must be verified against the PRD and Spec before proceeding.
- We recommend starting a new chat session when switching phases to maintain context focus.
To prevent context loss, hallucinations, and to enforce strict SDLC traceability, you MUST explicitly attach, mention (e.g., using @filename), or provide the required upstream documents in the prompt context when invoking an agent. You are also highly encouraged to include other relevant files or code snippets to complete the analysis.
If the mandatory files are not provided in the prompt context, the agent will halt execution and ask you to provide them.
| Agent / Phase | Mandatory Upstream Document(s) |
|---|---|
@ProductManagerPRD |
Project Discovery Draft (OR existing PRD for updates) |
@ClarificationAnalyst |
PRD, Spec, OR Plan (depending on target) |
@SpecificationArchitect |
Approved PRD (OR existing Spec for updates) |
@PlannerArchitect |
Approved Technical Spec (OR existing Plan for updates) |
@GodModeDev |
Implementation Plan OR Bug Remediation Plan |
@ExpertCodeReviewer |
Technical Spec AND Implementation Plan |
@ArtifactConsistencyChecker |
PRD, Spec, AND Plan |
@DiataxisDocumentationArchitect |
PRD, Technical Spec, Implementation Plan, OR Relevant Source Code files |
Note: Phase 0 (@BrainstormingExplorerAnalyst) and surgical bug analysis (@BugRemediationArchitect) rely on user briefs, codebase exploration, or bug reports, and do not have strictly enforced upstream SDLC documents, though providing relevant context is highly encouraged.
Following our strict sequential workflow, here is how you would develop a new feature:
Phase 0: Project Discovery
@BrainstormingExplorerAnalyst explore the codebase and write a discovery draft for the new shopping cart feature based on @business-brief.md
(Note: @business-brief.md is a placeholder for any human-written file provided by you, such as raw meeting notes, client requirements, or a simple text file with your ideas. Once the Discovery Draft is finalized, use memory-manager to save context, then open a new chat session)
Phase 1: Requirements & Clarification
@ProductManagerPRD create a PRD for the shopping cart feature based on @discovery-draft.md
(Once the PRD is complete and approved, use the memory-manager skill to save context, then open a new chat session to prevent context bleeding)
@ClarificationAnalyst interrogate the new @prd-shopping-cart.md for missing edge cases
(Answer the Clarification Analyst's questions one by one. Once finished and the PRD is revised, use memory-manager to save context, then proceed to the Spec phase in a new chat session)
Phase 2: Technical Specification
@SpecificationArchitect design a technical specification based on @prd-shopping-cart.md
(Once the Spec is complete, use memory-manager and open a new chat session)
@ClarificationAnalyst interrogate the new @spec-shopping-cart.md for any technical ambiguities
(Once the Spec interrogation is finalized, use memory-manager and open a new chat session)
@ArtifactConsistencyChecker verify that @spec-shopping-cart.md covers all requirements in @prd-shopping-cart.md
(If no PRD requirements are missing from the Spec, use memory-manager and open a new chat session)
Phase 3: Implementation Planning
@PlannerArchitect create a step-by-step implementation plan based on @spec-shopping-cart.md
(Once the Plan is created, use memory-manager and open a new chat session)
@ClarificationAnalyst interrogate the @plan-shopping-cart.md for any unhandled edge cases
(Once all edge cases in the Plan are addressed, use memory-manager to save context, then open a new chat session to begin coding)
Phase 4: Implementation & Review
@GodModeDev implement the shopping cart based on @plan-shopping-cart.md, and ensure all tests pass
(Once code implementation and testing are complete, use memory-manager and open a new chat session)
@ExpertCodeReviewer review the newly implemented service layer and suggest refactoring
(Apply any refactoring suggestions if needed, use memory-manager to save context, then open a new chat session for documentation)
Phase 5: Documentation & Bug Fixing
@DiataxisDocumentationArchitect write an API reference guide based on @spec-shopping-cart.md and @cart.js
(If bugs are discovered later, use the specialized bug remediation agent in a separate chat session)
@BugRemediationArchitect analyze the bug report in @issue-123.md and propose a fix for @cart.js
For small, surgical tasks (like renaming a function, tweaking CSS, or fixing a typo), forcing the full SDLC (PRD -> Spec -> Plan -> Code) is inefficient. You can use the "escape hatch" to bypass the SDLC protocol by explicitly commanding the agent.
Example Prompt for Minor Tasks:
@GodModeDev [Bypass SDLC] This is a minor fix. Please refactor the `calculateTotal` function in @cart.js to be more concise, and add some padding to the `.btn-checkout` class in @style.css.
Note: Even when bypassing the SDLC, you are still highly encouraged to attach the specific source code files (e.g., @cart.js, @style.css) to provide the agent with the necessary context.
In many platforms (such as VS Code Copilot, Antigravity, OpenCode), you can invoke the agent's underlying skill directly using the slash command syntax (/<skill-name>). Furthermore, to strictly comply with the Mandatory Context Injection Protocol, you should explicitly attach the required upstream documents and relevant source code files using the @filename syntax.
Phase 0: Project Discovery
/brainstorming-explorer explore the codebase and write a discovery draft for the new shopping cart feature based on @business-brief.md
(Note: @business-brief.md is a placeholder for any human-written file provided by you, such as raw meeting notes, client requirements, or a simple text file with your ideas)
Phase 1: Requirements & Clarification
/product-manager-prd create a PRD for the shopping cart feature based on @discovery-draft.md
/clarification-analyst interrogate the new @prd-shopping-cart.md for missing edge cases
Phase 2: Technical Specification & Audit
/specification-architect design a technical specification based on @prd-shopping-cart.md
/artifact-consistency-checker verify that @spec-shopping-cart.md strictly follows @prd-shopping-cart.md
Phase 3: Implementation Planning
/planner-architect create a step-by-step implementation plan based on @spec-shopping-cart.md
Phase 4: Execution & Coding
/god-mode-dev implement the shopping cart based on @plan-shopping-cart.md. Target files are @cart.js and @style.css
Phase 5: Documentation & Bug Fixing
/diataxis-documentation-architect write an API reference guide based on @spec-shopping-cart.md and @cart.js
/bug-remediation-architect analyze the bug report in @issue-123.md and propose a fix for @cart.js
- Adhere to the SDLC Sequence: Never skip a phase. Ensure that PRD, Specs, and Plans are fully fleshed out before invoking
@GodModeDevfor coding. - Platform-Specific Directories: Place your rules, skills, and agents in the correct directories for your platform (
.commandcode,.opencode,.agents,.claude,.github,.codex,.pi, or.omp). - Use Appropriate Agents: Match the agent to the current SDLC phase (e.g.,
@SpecificationArchitectfor specs,@ExpertCodeReviewerfor code audits). - Leverage Project Memory: Periodically save significant milestones using the
memory-managerskill to maintain context across different chat sessions. - Iterate and Verify: Always verify the outputs of an agent against the original PRD and Spec before proceeding to the next phase.
By default, the rules in this repository are configured to instruct the AI agents to communicate in Indonesian (Bahasa Indonesia).
If you prefer to interact in English or another language, you can easily change this. Open the AGENTS.md file and modify the following sections:
- Under
## Communication, change the language rule:- **Language**: Communication must use clear and proper English - Under
## User Communication Style, adjust the preference:- Uses formal but casual English
graph TD
%% Define Styles
classDef agent fill:#0d1117,color:#58a6ff,stroke:#30363d,stroke-width:2px;
classDef phase fill:#238636,color:#ffffff,stroke:#2ea043,stroke-width:2px,rx:10px,ry:10px;
%% Nodes
Phase0[Phase 0: Discovery]:::phase
Phase1[Phase 1: Requirements]:::phase
Phase2[Phase 2: Specification]:::phase
Phase3[Phase 3: Planning]:::phase
Phase4[Phase 4: Implementation & Code]:::phase
Phase5[Phase 5: Documentation]:::phase
AgentBEA["@BrainstormingExplorerAnalyst<br/>(Explores Code & Brainstorms)"]:::agent
AgentPM["@ProductManagerPRD<br/>(Creates PRD)"]:::agent
AgentCA1["@ClarificationAnalyst<br/>(Interrogates PRD)"]:::agent
AgentSA["@SpecificationArchitect<br/>(Creates Tech Spec)"]:::agent
AgentCA2["@ClarificationAnalyst<br/>(Interrogates Spec)"]:::agent
AgentACC["@ArtifactConsistencyChecker<br/>(Validates Traceability)"]:::agent
AgentPA["@PlannerArchitect<br/>(Creates Implementation Plan)"]:::agent
AgentCA3["@ClarificationAnalyst<br/>(Interrogates Plan)"]:::agent
AgentGMD["@GodModeDev<br/>(Writes Code & Tests)"]:::agent
AgentECR["@ExpertCodeReviewer<br/>(Audits Code)"]:::agent
AgentBRA["@BugRemediationArchitect<br/>(Fixes Bugs)"]:::agent
AgentDDA["@DiataxisDocumentationArchitect<br/>(Writes User Docs)"]:::agent
%% Flow
Phase0 --> AgentBEA
AgentBEA --> Phase1
Phase1 --> AgentPM
AgentPM --> AgentCA1
AgentCA1 --> Phase2
Phase2 --> AgentSA
AgentSA --> AgentCA2
AgentCA2 --> AgentACC
AgentACC --> Phase3
Phase3 --> AgentPA
AgentPA --> AgentCA3
AgentCA3 --> Phase4
Phase4 --> AgentGMD
AgentGMD --> AgentECR
AgentECR -.->|If issues/bugs| AgentBRA
AgentBRA -.-> AgentGMD
AgentECR --> Phase5
Phase5 --> AgentDDA
[ Phase 0: Discovery ]
|
v
(@BrainstormingExplorerAnalyst)
|
v
[ Phase 1: Requirements ]
|
v
(@ProductManagerPRD)
|
v
(@ClarificationAnalyst)
(Interrogate PRD)
|
v
[ Phase 2: Specification ]
|
v
(@SpecificationArchitect)
|
v
(@ClarificationAnalyst)
(Interrogate Spec)
|
v
(@ArtifactConsistencyChecker)
(Traceability)
|
v
[ Phase 3: Planning ]
|
v
(@PlannerArchitect)
|
v
(@ClarificationAnalyst)
(Interrogate Plan)
|
v
[ Phase 4: Implementation & Code ]
|
v
(@GodModeDev) ───────────────────> (@ExpertCodeReviewer)
^ |
| | (If bugs/issues)
| v
└───────────────────────── (@BugRemediationArchitect)
|
v
[ Phase 5: Documentation ]
|
v
(@DiataxisDocumentationArchitect)
Previously categorized as standalone "Prompts" and "Instructions", these optional capabilities have now been consolidated into the supplementary-skill/ directory as custom skills. These skills provide additional guidelines, workflows, and prompts that you can manually include in your platform's skills directory (e.g., .agents/skills/) to enhance your agents.
These skills enforce coding standards and best practices:
| Supplementary Skill | Description | Apply To |
|---|---|---|
| taming-copilot | Core directives for precise, surgical code assistance | All files (**) |
| clean-code-clean-architecture | Clean code principles and architecture patterns | All files (**) |
| strict-clean-code-clean-architecture | Strict enforcement of clean code/architecture | All files (**) |
| nodejs-codestyle | Node.js best practices and conventions | **/*.js, **/*.ts |
| eloquent-js-codestyle | Eloquent JavaScript style guide | **/*.js |
| php-laravel-codestyle | Laravel framework conventions | **/*.php |
| flutter-codestyle | Flutter and Dart best practices | **/*.dart |
| html-css-responsive | Responsive HTML/CSS design principles | **/*.html, **/*.css |
| markdown | Markdown formatting standards | **/*.md |
| memory | Project-specific context and preferences | All files (**) |
These skills provide structured workflows for common development tasks:
| Supplementary Skill | Description |
|---|---|
| create-readme | Generate comprehensive README files |
| create-specification | Create technical specifications |
| update-specification | Update existing specifications |
| create-implementation-plan | Generate implementation plans |
| update-implementation-plan | Update implementation plans |
| breakdown-feature-prd | Break down features from PRD |
| documentation-writer | Write technical documentation |
| review-and-refactor | Code review and refactoring |
| boost-prompt | Enhance and improve prompts |
| fixing-prompt | Debug and fix issues |
| remember | Store project context |
| project-memory-keeper | Maintain project memory |
Tip
Since these are now fully structured as skills, you can simply copy any desired folder from supplementary-skill/ into your active .agents/skills/ (or equivalent) directory to activate them.
A ready-to-use configuration template for enabling BYOK (Bring Your Own Key) on GitHub Copilot in Visual Studio Code. Use your own API keys from various providers (OpenRouter, DeepSeek, Opencode Zen, Opencode Go, Kilo Gateway, and others) to extend the list of available chat models.
Note
BYOK models work without a GitHub account or Copilot plan and are used for chat and utility tasks only. Some features (semantic search, inline suggestions, embeddings) still require GitHub Copilot.
See the full documentation and setup guide: byok-copilot-config/
You can implement customizations incrementally, starting with the simplest options and gradually adding more complexity as needed.
Create custom instructions for consistent results across all your chat interactions. Custom instructions let you define common guidelines or rules for tasks like generating code, performing code reviews, or generating commit messages.
File location: .commandcode/instructions/, .github/instructions/, .opencode/instructions/, or .agents/rules/
Format:
---
applyTo: "**/*.ts"
description: "TypeScript coding standards"
---
# Your instruction content here
- Use strict type checking
- Follow functional programming principles
- Always handle errors explicitlyUse custom instructions to:
- Specify coding practices, preferred technologies, or project requirements
- Provide guidelines about commit messages or PR descriptions
- Set rules for code reviews (security, performance, coding standards)
You can use AI assistants to help create custom instructions based on programming books or documentation:
-
Upload a programming book PDF (e.g., "Eloquent JavaScript", "Clean Code", "Design Patterns") to:
- Gemini AI (supports PDF upload)
- Claude AI (supports PDF upload)
- ChatGPT (supports PDF upload with Plus/Pro subscription)
-
Use this prompt:
Study this programming book PDF carefully and create a GitHub Copilot custom instruction file based on the principles, patterns, and best practices from the book. The instruction should: - Follow the .instructions.md format with YAML frontmatter - Include key principles from the book - Provide specific coding guidelines - Be practical and actionable for daily development -
Review and customize the generated instruction file to match your team's needs
-
Save the file to your platform's instructions directory (e.g.,
.github/instructions/) with a descriptive name (e.g.,eloquent-js-codestyle.instructions.md)
Tip
This method is especially useful for creating language-specific or framework-specific instructions based on authoritative sources.
Prompt files let you define reusable prompts for common and repeatable development tasks. They're standalone prompts you can run directly in chat.
File location: .commandcode/prompts/, .github/prompts/, .opencode/prompts/, or .agents/prompts/
Format:
---
agent: "agent"
description: "Create technical specifications"
---
## Role
You are a technical architect...
## Task
1. Analyze the feature requirements
2. Create a detailed technical specificationUse prompt files to:
- Create reusable prompts for common coding tasks (scaffolding components, generating tests)
- Define prompts for code reviews
- Create step-by-step guides for complex processes
- Generate implementation plans or architectural designs
Custom agents are specialist assistants for specific roles or tasks. Within a custom agent file, you describe its scope, capabilities, which tools it can access, and preferred language model.
File location: .commandcode/agents/, .github/agents/, .opencode/agents/, or .agents/rules/
Format:
---
description: "Frontend Developer Specialist"
tools: ["edit", "search", "runCommands"]
---
# Frontend Developer Agent
You are a frontend development specialist focusing on React and TypeScript...Use custom agents to:
- Create a planning agent with read-only access for implementation plans
- Define a research agent that can reach external resources
- Create specialized agents for specific domains (frontend, backend, database, etc.)
Connect external services and specialized tools through Model Context Protocol (MCP) to extend chat capabilities beyond code.
Use MCP and tools to:
- Connect database tools to query and analyze data
- Integrate with external APIs for real-time information
Switch between different AI models optimized for specific tasks using the model picker in chat.
Use different models for:
- Fast models for quick code suggestions and simple refactoring
- Capable models for complex architectural decisions or detailed reviews
- Specialized models for vision processing or other specific tasks
Contributions are welcome! Whether it's:
- Adding new agents for specific development scenarios
- Improving existing instructions
- Creating new prompt templates
- Fixing bugs or improving documentation
Please feel free to submit a Pull Request.
- GitHub Copilot Customization Overview - Official VS Code documentation for customizing GitHub Copilot
- GitHub Copilot Documentation
- VS Code GitHub Copilot Extension
- Awesome Copilot - A curated list of GitHub Copilot resources, extensions, and examples
- VS Code BYOK Documentation - Official guide for bringing your own language model keys
- BYOK Config Template - Pre-built
chatLanguageModels.jsontemplate included in this repository
If you find this repository helpful, please consider giving it a star! It helps others discover these resources.
This project is open source and available under the MIT License.