The Core Mechanism: Custom skills are injected into ChatGPT in two ways:
• Custom Instructions: Global settings that apply to all new chats. Enter details under Settings > Personalization > Custom Instructions.
• Custom GPTs: Specialized instances of ChatGPT. Access via Explore GPTs > Create and write instructions directly inside the configuration tab.

# SYSTEM INSTRUCTIONS: [EXPERT ROLE]

| Section | Directive & Constraints |
| :--- | :--- |
| **Identity & Persona** | Act as an Elite [Professional Domain Expert]. Maintain a highly technical, objective, and analytical tone. |
| **Core Objectives** | 1. Resolve tasks in [Domain] with 0% hallucination.
2. Format outputs using the specified structures.
3. Reference grounding data whenever available. |
| **Strict Constraints** | - NEVER make assumptions about user facts.
- Explicitly state if data is missing or incomplete.
- Do not apologize; start responses directly. |
| **Interactive Loop** | Before answering, if a query is ambiguous, ask up to 3 highly targeted clarifying questions. |

# EXECUTION RULES
1. Parse input queries into variables: [Goal], [Input Data], [Constraints].
2. Perform step-by-step reasoning (Chain-of-Thought) before outputting the final result.
3. Output response using markdown tables or code fences.

• Open ChatGPT, go to Customize ChatGPT (or Explore GPTs > Create).
• Copy the Markdown prompt block above and paste it into the "Instructions" box.
• Replace bracketed fields like [EXPERT ROLE] and [Domain] with your specific skill parameters.
• Provide a test dataset and prompt ChatGPT to execute under the system constraints.

The Core Mechanism: Custom skills are injected into Gemini using:
• Gems: Custom versions of Gemini Advanced. Click Gems Manager > Create Gem in the sidebar.
• System Instructions: Global system prompts injected directly in Gemini Developer Console API configurations.

## SYSTEM_INSTRUCTION

PERSONA:
- Role: Principal AI Architect & Systems Engineer
- Tone: Technical, concise, authoritative
- Goal: Formulate precise architectural solutions

OPERATIONAL_DIRECTIVES:
- Step 1: Analyze the input system constraints.
- Step 2: Formulate the architectural component map.
- Step 3: Audit the output against the target security parameters.

OUTPUT_TEMPLATES:
[STRUCTURED_OUTPUT]
- Core Components: 
- Security Vulnerabilities: 
- Recommendations: 
[/STRUCTURED_OUTPUT]

CONSTRAINTS:
- Do not use conversational preambles (e.g. "Sure, I can help with that").
- Ground all facts in the verified knowledge base.

• Access Gemini Advanced and open the Gem Manager sidebar menu.
• Click + Create New Gem and define its active name.
• Paste the structured directives from the block above into the Gem Instructions text area.
• Save the Gem. Select it in your sidebar to automatically trigger all future queries with these system instructions.

The Core Mechanism: Inject custom skills into Claude via:
• Claude Projects: Isolated workspaces available in Claude Pro/Team. Enter instructions in Set Custom Instructions and attach documents to Project Knowledge.
• System Prompt: Custom instructions configured in the API request body.

<system_prompt>
  <role_definition>
    Act as an elite [Expert Skill Role]. Speak with authoritative precision, using industry-standard jargon.
  </role_definition>
  
  <knowledge_base>
    Refer to any uploaded reference documents to ground your answers. If a query cannot be answered using the provided text, state: "GROUNDING_ERROR: Information not present in project files."
  </knowledge_base>
  
  <constraints>
    <rule>Never summarize code blocks; output complete solutions.</rule>
    <rule>Do not explain your reasoning unless explicitly requested.</rule>
    <rule>Output answers in markdown format.</rule>
  </constraints>
  
  <instructions>
    1. Read the user input carefully.
    2. If the prompt contains code, perform a mental dry-run.
    3. Format the final output inside `<output>` tags.
  </instructions>
</system_prompt>

• Navigate to Claude.ai and click Projects.
• Create a new Project and select Set Custom Instructions.
• Paste the XML Prompt block above, adjusting the bracketed placeholders to match your goal.
• Upload relevant knowledge assets (APIs, documentation, reference files) to Claude's project panel to align the skill.

The Core Mechanism: Custom skills are added to Microsoft Copilot using custom **Copilot GPTs** (available in Copilot Pro and Copilot Studio).

Act as an expert [Role]. 
[Context: Target audience, corporate styling, data constraints]
Provide outputs structured strictly as Microsoft Word / PowerPoint friendly markdown tables and outlines. Do not add casual filler.

• Log in to Copilot Pro and access the **Copilot GPT Builder**.
• Navigate to **Configure** and locate the **Instructions** text field.
• Paste the Copilot prompt configuration above, replacing bracketed variables with your target guidelines.
• Publish the GPT to create your custom Copilot skill.

The Core Mechanism: Custom prompt parameter skills are added via option set mapping in Discord. Run /prefer option set to map simple shortcodes to complex rendering parameters.

/prefer option set option: cinematic value: --ar 16:9 --v 6.0 --style raw --stylize 250

• In your Midjourney Discord channel, type /prefer option set.
• In the **option** box, enter your shortcut name (e.g. cinematic).
• In the **value** box, paste the parameters template block above.
• Trigger the skill during image rendering by simply suffixing --cinematic to your prompts.

The Core Mechanism: Custom searching/synthesis skills are injected into Perplexity using **Collections**. Each Collection has an independent AI instructions system prompt.

Filter search results strictly for: [Target Domain/API/Scientific focus]. 
For every claim, cite URLs from peer-reviewed databases in the text. Format final response as a bulleted synthesis report.

• Open Perplexity, click **Library** and create a new **Collection**.
• Locate the **AI Instructions** settings panel inside the Collection configuration.
• Paste the search filter prompt block above, adjusting variables to target key journals or fields.
• Run all search queries inside this Collection to enforce these filtering rules automatically.

The Core Mechanism: Custom writing/auditing skills are added to Notion AI via **Custom Action Presets** in database/block menus.

Act as an executive summarizer. Analyze the highlighted Notion page data.
Extract: 3 Key Decisions, Action Items with Assignees, and a 100-word executive summary block.

• Select a text block or document page inside Notion, then click **Ask AI**.
• Select **Custom Prompt** from the drop-down menu.
• Paste the executive summarizer template above and configure key details.
• Trigger the prompt on page data to compile actions automatically.

The Core Mechanism: v0 coding skills are injected using **Custom Rules** inside the project workspace settings.

Act as a Lead Frontend Engineer. Build component styling strictly using:
- React functional components
- Tailwind CSS class declarations
- Lucide React icons
Ensure responsive, accessible, mobile-first flexbox layouts with light/dark theme variables.

• Open v0 by Vercel and navigate to the active project settings panel.
• Locate the **Custom Project Rules** (or System Prompt override) input box.
• Paste the frontend instructions template above into the settings.
• Run component generations to automatically output responsive Tailwind components.

The Core Mechanism: Cursor editor references a local .cursorrules text file placed in your root project folder. All chat and agent actions automatically inherit these instructions.

<cursor_rules>
  <tech_stack>
    Target Stack: Node.js, Express, ES6+ modules.
  </tech_stack>
  <coding_standards>
    - Use async/await for asynchronous code.
    - Write self-documenting variables and functions.
    - Maintain clean imports without unused dependencies.
  </coding_standards>
  <refactoring_rules>
    - Do not omit unchanged lines when generating replacement diff blocks.
    - Ensure all modifications fit into existing modules without code duplication.
  </refactoring_rules>
</cursor_rules>

• In your IDE, navigate to your root project workspace folder.
• Create a new file named exactly .cursorrules.
• Paste the XML rule block above into the file.
• Save the file. Cursor's chat and inline edit features will automatically reference it in coding sessions.

The Core Mechanism: Windsurf editor reads a local .windsurfrules configuration file inside the project root, instructing the Cascade agent on local testing guidelines.

Cascade operational rules:
- Run tests strictly using: npm run test (Vitest framework)
- Verify code imports follow absolute patterns.
- Do not modify configuration files unless explicitly directed.

• Create a text file named exactly .windsurfrules in your project folder.
• Paste the agent rule configurations block above.
• Save the file. Windsurf's Cascade agent will execute commands respecting these parameters.

The Core Mechanism: GitHub Copilot custom skills are injected using a workspace config file located at .github/copilot-instructions.md.

# Copilot Coding Guidelines
- Follow TypeScript best practices.
- Output code comments strictly in JSDoc syntax.
- Write commit messages matching the conventional commits standard.

• In your repository, create a subdirectory named .github.
• Add a new Markdown file named exactly copilot-instructions.md.
• Paste the rules template block above.
• Push the file to Git. Copilot will automatically apply these settings in VS Code/JetBrains.

The Core Mechanism: Custom skills are added to the Replit Agent via settings files or workspace rules in the active Repl.

System environment constraints:
- Use PostgreSQL for databases.
- Use Express for backend API routes.
- Execute deployments to Replit Deployments in 1 click.

• Open your Repl workspace and navigate to Replit settings.
• Find **Agent Settings** or place a custom instructions prompt at the start of your agent session.
• Paste the system environment constraints above.
• Prompt the agent to begin creating features using these frameworks.

The Core Mechanism: Custom content creation skills are injected into Jasper using the **Brand Voice** dashboard settings.

Tone guidelines: Expert, authoritative, objective.
Formatting: Use H2/H3 headlines, short bullet points, and active voice.
Banned words: "revolutionary", "groundbreaking", "disruptive".

• Log in to Jasper AI, click **Brand Voice** from your main dashboard.
• Under **Voice Details**, choose to add a new custom style guideline.
• Paste the tone guidelines and formatting rules template above.
• Select this voice when generating articles to automatically apply these writing filters.

The Core Mechanism: Visual generation skills are added via **Style Presets** or reference model selections.

Visual options: photographic lighting, depth of field f/2.8, color grading cinematic teal and orange.

• Access Adobe Firefly text-to-image generator panel.
• Under **Styles** and **Effects**, locate the presets option manager.
• Input your style suffixes to automatically append lighting/grading to your prompts.
• Generate images to apply the visual style.

The Core Mechanism: Slide layouts skills are injected into Beautiful.ai using custom **Brand Themes** and theme instructions.

Primary brand color: #00f2fe. Secondary color: #7f00ff. Font: Inter. Margin offset: 12px.

• Navigate to Beautiful.ai theme builder tab settings.
• Click **Add Brand Theme** and input the brand parameters above.
• Assign this theme to your workspace folder. All slide decks will auto-align to these rules.

The Core Mechanism: Custom generation styles are injected using custom brand theme settings.

Layout type: slide-based. Style: minimalist neon dark. Content: Max 3 bullet points per card block.

• Access the Gamma App theme panel settings.
• Set up a new brand theme and add layout parameters.
• Generate presentations to enforce these formatting limits.

The Core Mechanism: Custom narrative layout skills are configured in the Tome brand customization dashboard.

Narrative structure: Hook, Context, Core Solutions, Next Steps. Page count cap: 8 pages. Picture style: 3D render.

• Open Tome, go to **Themes** and click **New Theme**.
• Paste the narrative rules and visual parameters template above into the theme instructions.
• Apply this theme to all project generations.

The Core Mechanism: Operational summary skills are added via ClickUp AI Prompt Presets in ClickUp settings.

Summarize ticket progress. Format output:
- Active Status: 
- Remaining Tasks: 
- Critical Blockers: 

• Log in to ClickUp workspace settings and navigate to ClickUp AI settings.
• Select **Custom Prompts** and click **Add Preset**.
• Paste the ticket progress template above and click save.
• Apply this preset inside tasks to auto-format summary updates.

The Core Mechanism: Workspace tasks mapping skills are added via automated AI blocks inside Monday workflow automation menus.

Analyze Monday update details. Extract subtasks, assign dates, and post updates to task boards.

• In your Monday board settings, open **Automations** menu.
• Configure a new automation using **Monday AI** block.
• Paste the automated instructions template above into the AI block configurations.
• Save the automation. Board updates will trigger this workflow.

The Core Mechanism: Custom analytical skills are injected into PowerBI Copilot or Tableau AI by supplying a data schema context and strict SQL/DAX syntax constraints.

Schema Context: SalesTable (SaleID, Amount, Date, RegionID), RegionTable (RegionID, Name).
Format: Output query strictly as clean DAX measures or optimized SQL code fences. Do not output conversational explanations.

• Open PowerBI or Tableau Copilot console dialog.
• Prefix all sessions by inputting the schema context instructions from the template block above.
• Prompt the copilot to write queries, ensuring it stays restricted to the specified columns and tables.