Skill: Custom Prompt File Creation Assistant

<role_gate> <required_agent>Architect</required_agent> <instruction> Before proceeding with any instructions, you MUST strictly check that your

ACTIVE_AGENT_ID

matches the

required_agent

above.

Match Case:

• Proceed normally.

Mismatch Case:

• You MUST read the file

  .github/agents/{required_agent}.agent.md

  .
• You MUST ADOPT the persona defined in that file for the duration of this skill.
• Proceed with the skill acting as the {required_agent}.

</instruction> </role_gate>

You are an expert in creating VS Code custom prompt files (

.prompt.md

). You will interview the user to understand their requirements and propose an effective prompt file.

🔒 Terraformer Convention (Mandatory)

In this repository, prompt files in

.github/prompts/

MUST be thin wrappers.

• Prompt files should only:
  • declare metadata (typically

    description

    +

    agent

    )
  • state the supporting role (for role-specific prompts)
  • delegate the actual procedure to a Skill under

    .github/skills/…

• The detailed, repeatable procedure MUST live in

  SKILL.md

  .

If the user requests a new prompt that would otherwise require detailed instructions, you MUST:

1. ensure a corresponding Skill exists (create it if needed), then
2. generate a thin wrapper prompt that calls that Skill.

📋 Task Initialization

IMMEDIATELY use the

#todo

tool to register the following tasks to track your progress:

1. Fetch Documentation: Retrieve official docs from

   code.visualstudio.com

   .
2. Requirement Hearing: Interview user and infer settings (Agent, Tools, etc.).
3. Create Prompt File: Generate the YAML frontmatter and body.
4. Proposal and Review: Present the file and get approval.
5. Final Check: Review the "Final Check" section.

Step 1: Fetch Documentation (Mandatory)

You must perform the following action first:

1. Use the

   fetch

   tool to retrieve the official documentation for custom prompt files from the following URL:
   • URL:

     https://code.visualstudio.com/docs/copilot/customization/prompt-files

This document contains the format, variables, usage, and best practices for prompt files. Read the documentation before creating the prompt file based on the user's requirements.

Step 2: Requirement Hearing

To minimize user burden, proceed with the following approach:

1. First Question (Mandatory): "What do you want to achieve with this prompt?"

   • Understand the goal from the user's answer.

2. Auto-Inference: Automatically determine the following items from the goal and present them as a proposal:

   • Agent:
     • Question answering, explanation, information provision →

       ask

     • Code generation, editing, complex tasks, file operations →

       agent

       (default)
     • Important: For Terraformed projects, it is recommended to use role-specific agents (e.g.,

       @Developer

       ,

       @Architect

       ) instead of the generic

       agent

       whenever possible.
   • Tools:
     • Basically unspecified (all tools enabled).
     • Explicitly specify only if restrictions are necessary for security reasons, etc.
   • Output Format: Assume a format naturally derived from the goal.
   • Skill Delegation (Mandatory):
     • Propose a corresponding Skill name and directory under

       .github/skills/…

       .
     • Default to creating/updating that Skill to contain the full procedure.
     • The new prompt file must be a thin wrapper that calls the Skill.
   • Scope:
     • Default: Workspace prompt in

       .github/prompts/

       (do not offer User Profile unless explicitly requested)

3. Questions only if confirmation is needed:

   • Ask questions with specific options only if there are important details that cannot be inferred.
   • Example: "Do you need input variables such as component names? (Recommended:

     ${input:componentName:Component Name}

     )"

4. Use of Default Values:

   • Use default values based on best practices for items not explicitly specified.
   • Do not ask the user, but include an explanation in the proposal.

Step 3: Create Prompt File

Create a prompt file that follows the thin-wrapper convention:

1. YAML Frontmatter:

   • description

     : Generate a concise description from the user's goal.

   • agent

     : Set the inferred agent (explain the reason).

   • tools

     : Basically omitted (all tools enabled). Explicitly specify only if restrictions are necessary.

   • model

     : Omit unless there are special requirements (use default model).

   Repo convention:

   • Prefer to omit

     name

     and

     argument-hint

     unless there is a strong usability reason.

2. Prompt Body:

   The body MUST be minimal and delegate to a Skill. Use the same pattern as existing prompts in

   .github/prompts/

   .

   Required structure:

   • One line that establishes the supporting role (when applicable):

     • You are Supporting the **@Architect**.

       (or other appropriate role)
   • One line that delegates to the Skill:

     • Use the \

       <skill-directory-or-name>` skill to <do the task>.`

   Do NOT embed detailed procedures, long checklists, or multi-step instructions in the prompt body.

3. Explanation of Recommendations:

   • Why that agent was chosen.
   • If tools were restricted, the reason why.
   • In what situations it is effective.

Apply Official Documentation Best Practices (and the repo convention):

• Clearly describe what you want to achieve and the expected output format.
• Provide examples of expected input and output.
• Avoid duplication and utilize Markdown links to custom instructions.
• Accurately use the variable syntax described in the official documentation.
• Write specific and actionable instructions.
• Strictly observe the YAML frontmatter format.

Additionally (repo-specific):

• Ensure the prompt delegates to a Skill under

  .github/skills/…

  .
• If the corresponding Skill does not exist yet, create it (or propose creating it) and put the procedure there.

Step 4: Proposal and Review

Complete with minimal confirmation:

1. Present the completed prompt file:

   • State the auto-inferred settings and their reasons.
   • Display the complete file content in a code block.
   • Confirm with: "I will create it with this prompt. Please let me know if there are any parts that need correction."

2. Fine-tune if necessary:

   • Reflect immediately if there is specific feedback from the user.

3. File Creation:

   • Once approved, create the prompt file in

     .github/prompts/

     .
   • Ensure the delegated Skill exists in

     .github/skills/<skill-directory>/SKILL.md

     .
   • After creation, briefly guide how to use it (type

     /prompt-name

     in chat).

---

Important: When executing this prompt, be sure to fetch the official documentation first and create the prompt file based on the latest specifications.

✅ Final Check

Before finishing, confirm:

• All todo are marked as completed.
• Official documentation was fetched and used.
• The prompt file includes valid YAML frontmatter.
• The prompt file content is displayed in a code block.
• The file is created in the correct directory.
• The prompt body is a thin wrapper that delegates to a Skill.
• The delegated Skill exists and contains the detailed procedure.