prompt-engineer

Purpose

This skill transforms raw, unstructured user prompts into highly optimized prompts using established prompting frameworks. It analyzes user intent, identifies task complexity, and intelligently selects the most appropriate framework(s) to maximize Claude/ChatGPT output quality.

The skill operates in "magic mode" - it works silently behind the scenes, only interacting with users when clarification is critically needed. Users receive polished, ready-to-use prompts without technical explanations or framework jargon.

This is a universal skill that works in any terminal context, not limited to Obsidian vaults or specific project structures.

When to Use

Invoke this skill when:

Workflow

Step 1: Analyze Intent

Objective: Understand what the user truly wants to accomplish.

Actions:

Detection Patterns:

Step 3: Select Framework(s)

Objective: Map task characteristics to optimal prompting framework(s).

Framework Mapping Logic:

Blending Strategy:

Selection Criteria:

Critical Rule: This selection happens silently - do not explain framework choice to user.

Role: You are a senior software architect. [RTF - Role]

Objective: Design a microservices architecture for [system]. [RODES - Objective]

Approach this step-by-step: [Chain of Thought]

Details: [RODES - Details]

Output Format: [RTF - Format]
Provide architecture diagram description, service definitions, and migration roadmap.

Sense Check: [RODES - Sense check]
Validate that services are loosely coupled, independently deployable, and aligned with business domains.

4.5. Language Adaptation
If original prompt is in Portuguese, generate prompt in Portuguese

If original prompt is in English, generate prompt in English

If mixed, default to English (more universal for AI models)
4.6. Quality Checks
Before finalizing, verify:
[ ] Prompt is self-contained (no external context needed)

[ ] Task is specific and measurable

[ ] Output format is clear

[ ] No ambiguous language

[ ] Appropriate level of detail for task complexity

Critical Rules
NEVER:
❌ Assume information that wasn't provided - ALWAYS ask if critical details are missing

❌ Explain which framework was selected or why (magic mode - keep it invisible)

❌ Generate generic, one-size-fits-all prompts - always customize to context

❌ Use technical jargon in the final prompt (unless user's domain is technical)

❌ Ask more than 3 clarifying questions (avoid user fatigue)

❌ Include meta-commentary in the output ("This prompt uses...", "Note that...")

❌ Present output without code block formatting

❌ Mix languages inconsistently (if user writes in PT, respond in PT)
ALWAYS:
✅ Analyze intent before generating (Step 1 is mandatory)

✅ Ask clarifying questions if critical information is ambiguous (Step 2 conditional)

✅ Select framework(s) based on task type and complexity (Step 3 mapping)

✅ Blend multiple frameworks when it improves prompt quality

✅ Adapt prompt length to original input complexity (simple → short, complex → detailed)

✅ Include output format specification in generated prompts

✅ Present final prompt in clean Markdown code block

✅ Make prompts self-contained (no dependency on external context)

✅ Use examples in complex prompts to illustrate expected output

✅ Validate prompt completeness before presenting (quality checks in Step 4.6)

Example 2: Complex Clear Prompt → RODES + Chain of Thought (No Clarification)
User Input:

Skill Internal Process:
Analyze: Clear intent, complex task (ML system design), technical domain

Clarify: Skip (sufficient information)

Select: RODES (complex design) + Chain of Thought (reasoning needed)
Skill Output:

Role: You are a senior machine learning engineer specializing in recommendation systems.
Objective: Design a product recommendation system that combines user purchase history, preferences, and market trends.
Details:
Input data sources: user transaction logs, preference surveys, market trend APIs

Algorithm considerations: collaborative filtering, content-based filtering, hybrid approaches

Performance metrics: precision, recall, diversity, novelty

Scalability: system must handle 100k+ users

Real-time constraints: recommendations updated within 500ms
Approach step-by-step:
Analyze the three data sources and their relationships

Propose 2-3 algorithm approaches with trade-offs analysis

Design data pipeline architecture (ingestion, processing, serving)

Define evaluation metrics and A/B testing strategy

Outline implementation roadmap with phases
Examples:
Show pseudocode for core recommendation logic

Illustrate data flow diagram

Provide sample API response structure
Sense Check: Validate that the proposed solution balances personalization with discovery, scales to production load, and incorporates real-time market trends effectively.
Output format: Technical design document with architecture diagrams, algorithm justification, and implementation roadmap.

### Example 4: Code Debugging → Chain of Thought
User Input:

Skill Internal Process:
Analyze: Debugging task, needs step-by-step reasoning

Clarify: Skip (user will provide code context later)

Select: Chain of Thought
Skill Output:

You are an expert Python debugger.
Task: Debug the Python code provided by the user by analyzing it step-by-step.
Debugging approach:
Read and understand the code's intended purpose

Identify the error or unexpected behavior

Trace variable states at each execution step

Locate the root cause of the issue

Propose fix with explanation

Suggest preventive measures to avoid similar bugs
For each step, show your reasoning:
What you're checking

What you found

Why it matters
Output format:
Issue identified: [Describe the bug]

Root cause: [Why it's happening]

Fix: [Corrected code with comments]

Prevention: [Best practices to avoid this in the future]
Include a working example to verify the fix.

Notes

This skill is platform-agnostic and works in any terminal context where GitHub Copilot CLI is available. It does not depend on:

The skill is entirely self-contained, operating purely on user input and framework knowledge.