@hybridlabor-api/bdb-antigravity-skills 1.0.0

package/skills/global_config/prompt-engineer/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: prompt-engineer
+description: "Transforms user prompts into optimized prompts using frameworks (RTF, RISEN, Chain of Thought, RODES, Chain of Density, RACE, RISE, STAR, SOAP, CLEAR, GROW)"
+category: automation
+risk: safe
+source: community
+tags: "[prompt-engineering, optimization, frameworks, ai-enhancement]"
+date_added: "2026-02-27"
+---
+
+## 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:
+
+- User provides a vague or generic prompt (e.g., "help me code Python")
+- User has a complex idea but struggles to articulate it clearly
+- User's prompt lacks structure, context, or specific requirements
+- Task requires step-by-step reasoning (debugging, analysis, design)
+- User needs a prompt for a specific AI task but doesn't know prompting frameworks
+- User wants to improve an existing prompt's effectiveness
+- User asks variations of "how do I ask AI to..." or "create a prompt for..."
+
+## Workflow
+
+### Step 1: Analyze Intent
+
+**Objective:** Understand what the user truly wants to accomplish.
+
+**Actions:**
+1. Read the raw prompt provided by the user
+2. Detect task characteristics:
+   - **Type:** coding, writing, analysis, design, learning, planning, decision-making, creative, etc.
+   - **Complexity:** simple (one-step), moderate (multi-step), complex (requires reasoning/design)
+   - **Clarity:** clear intention vs. ambiguous/vague
+   - **Domain:** technical, business, creative, academic, personal, etc.
+3. Identify implicit requirements:
+   - Does user need examples?
+   - Is output format specified?
+   - Are there constraints (time, resources, scope)?
+   - Is this exploratory or execution-focused?
+
+**Detection Patterns:**
+- **Simple tasks:** Short prompts (<50 chars), single verb, no context
+- **Complex tasks:** Long prompts (>200 chars), multiple requirements, conditional logic
+- **Ambiguous tasks:** Generic verbs ("help", "improve"), missing object/context
+- **Structured tasks:** Mentions steps, phases, deliverables, stakeholders
+
+
+### Step 2: Ask Clarifying Questions (Conditional)
+
+**Objective:** Gather missing information only when it is critical to framework selection or prompt quality.
+
+**Trigger Conditions** — ask only if:
+- Task type is completely ambiguous (cannot determine coding vs. writing vs. analysis)
+- Target audience is unknown and materially affects the output
+- Scope is undefined and choosing wrong scope would invalidate the prompt
+- Requested output format conflicts or is missing and cannot be inferred
+
+**Question Limits:**
+- Maximum 3 questions per invocation
+- Combine related questions into one when possible
+- If enough context exists, skip this step entirely (most cases)
+
+**Example Clarifying Exchange:**
+
+```
+User: "help me with AI"
+
+Step 2 (triggered — task type ambiguous):
+"To craft the best prompt, I need one quick clarification:
+1. What do you want to do with AI — build something, learn about it, or use an AI tool for a task?"
+```
+
+**Critical Rule:** When in doubt, skip clarification and generate the best prompt with available context. Over-asking breaks the "magic mode" experience.
+
+
+### Step 3: Select Framework(s)
+
+**Objective:** Map task characteristics to optimal prompting framework(s).
+
+**Framework Mapping Logic:**
+
+| Task Type | Recommended Framework(s) | Rationale |
+|-----------|-------------------------|-----------|
+| **Role-based tasks** (act as expert, consultant) | **RTF** (Role-Task-Format) | Clear role definition + task + output format |
+| **Step-by-step reasoning** (debugging, proof, logic) | **Chain of Thought** | Encourages explicit reasoning steps |
+| **Structured projects** (multi-phase, deliverables) | **RISEN** (Role, Instructions, Steps, End goal, Narrowing) | Comprehensive structure for complex work |
+| **Complex design/analysis** (systems, architecture) | **RODES** (Role, Objective, Details, Examples, Sense check) | Balances detail with validation |
+| **Summarization** (compress, synthesize) | **Chain of Density** | Iterative refinement to essential info |
+| **Communication** (reports, presentations, storytelling) | **RACE** (Role, Audience, Context, Expectation) | Audience-aware messaging |
+| **Investigation/analysis** (research, diagnosis) | **RISE** (Research, Investigate, Synthesize, Evaluate) | Systematic analytical approach |
+| **Contextual situations** (problem-solving with background) | **STAR** (Situation, Task, Action, Result) | Context-rich problem framing |
+| **Documentation** (medical, technical, records) | **SOAP** (Subjective, Objective, Assessment, Plan) | Structured information capture |
+| **Goal-setting** (OKRs, objectives, targets) | **CLEAR** (Collaborative, Limited, Emotional, Appreciable, Refinable) | Goal clarity and actionability |
+| **Coaching/development** (mentoring, growth) | **GROW** (Goal, Reality, Options, Will) | Developmental conversation structure |
+
+**Blending Strategy:**
+- **Combine 2-3 frameworks** when task spans multiple types
+- Example: Complex technical project → **RODES + Chain of Thought** (structure + reasoning)
+- Example: Leadership decision → **CLEAR + GROW** (goal clarity + development)
+
+**Selection Criteria:**
+- Primary framework = best match to core task type
+- Secondary framework(s) = address additional complexity dimensions
+- Avoid over-engineering: simple tasks get simple frameworks
+
+**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]
+1. Analyze current monolithic constraints
+2. Identify service boundaries
+3. Design inter-service communication
+4. Plan data consistency strategy
+
+Details: [RODES - Details]
+- Expected traffic: [X]
+- Data volume: [Y]
+- Team size: [Z]
+
+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:**
+```
+copilot> create prompt for: I need to build a product recommendation system considering purchase history, user preferences, and market trends
+```
+
+**Skill Internal Process:**
+1. **Analyze:** Clear intent, complex task (ML system design), technical domain
+2. **Clarify:** Skip (sufficient information)
+3. **Select:** RODES (complex design) + Chain of Thought (reasoning needed)
+
+**Skill Output:**
+
+````markdown
+```
+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:
+1. Analyze the three data sources and their relationships
+2. Propose 2-3 algorithm approaches with trade-offs analysis
+3. Design data pipeline architecture (ingestion, processing, serving)
+4. Define evaluation metrics and A/B testing strategy
+5. 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:**
+```
+copilot> optimize prompt: my Python code isn't working, needs debugging
+```
+
+**Skill Internal Process:**
+1. **Analyze:** Debugging task, needs step-by-step reasoning
+2. **Clarify:** Skip (user will provide code context later)
+3. **Select:** Chain of Thought
+
+**Skill Output:**
+
+````markdown
+```
+You are an expert Python debugger.
+
+Task: Debug the Python code provided by the user by analyzing it step-by-step.
+
+Debugging approach:
+1. Read and understand the code's intended purpose
+2. Identify the error or unexpected behavior
+3. Trace variable states at each execution step
+4. Locate the root cause of the issue
+5. Propose fix with explanation
+6. 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:
+- Obsidian vault structure
+- Specific project configurations
+- External files or templates
+
+The skill is entirely self-contained, operating purely on user input and framework knowledge.
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_config/prompt-engineering-patterns/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: prompt-engineering-patterns
+description: "Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability."
+risk: unknown
+source: community
+date_added: "2026-02-27"
+---
+
+# Prompt Engineering Patterns
+
+Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability.
+
+## Do not use this skill when
+
+- The task is unrelated to prompt engineering patterns
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Designing complex prompts for production LLM applications
+- Optimizing prompt performance and consistency
+- Implementing structured reasoning patterns (chain-of-thought, tree-of-thought)
+- Building few-shot learning systems with dynamic example selection
+- Creating reusable prompt templates with variable interpolation
+- Debugging and refining prompts that produce inconsistent outputs
+- Implementing system prompts for specialized AI assistants
+
+## Core Capabilities
+
+### 1. Few-Shot Learning
+- Example selection strategies (semantic similarity, diversity sampling)
+- Balancing example count with context window constraints
+- Constructing effective demonstrations with input-output pairs
+- Dynamic example retrieval from knowledge bases
+- Handling edge cases through strategic example selection
+
+### 2. Chain-of-Thought Prompting
+- Step-by-step reasoning elicitation
+- Zero-shot CoT with "Let's think step by step"
+- Few-shot CoT with reasoning traces
+- Self-consistency techniques (sampling multiple reasoning paths)
+- Verification and validation steps
+
+### 3. Prompt Optimization
+- Iterative refinement workflows
+- A/B testing prompt variations
+- Measuring prompt performance metrics (accuracy, consistency, latency)
+- Reducing token usage while maintaining quality
+- Handling edge cases and failure modes
+
+### 4. Template Systems
+- Variable interpolation and formatting
+- Conditional prompt sections
+- Multi-turn conversation templates
+- Role-based prompt composition
+- Modular prompt components
+
+### 5. System Prompt Design
+- Setting model behavior and constraints
+- Defining output formats and structure
+- Establishing role and expertise
+- Safety guidelines and content policies
+- Context setting and background information
+
+## Quick Start
+
+```python
+from prompt_optimizer import PromptTemplate, FewShotSelector
+
+# Define a structured prompt template
+template = PromptTemplate(
+    system="You are an expert SQL developer. Generate efficient, secure SQL queries.",
+    instruction="Convert the following natural language query to SQL:\n{query}",
+    few_shot_examples=True,
+    output_format="SQL code block with explanatory comments"
+)
+
+# Configure few-shot learning
+selector = FewShotSelector(
+    examples_db="sql_examples.jsonl",
+    selection_strategy="semantic_similarity",
+    max_examples=3
+)
+
+# Generate optimized prompt
+prompt = template.render(
+    query="Find all users who registered in the last 30 days",
+    examples=selector.select(query="user registration date filter")
+)
+```
+
+## Key Patterns
+
+### Progressive Disclosure
+Start with simple prompts, add complexity only when needed:
+
+1. **Level 1**: Direct instruction
+   - "Summarize this article"
+
+2. **Level 2**: Add constraints
+   - "Summarize this article in 3 bullet points, focusing on key findings"
+
+3. **Level 3**: Add reasoning
+   - "Read this article, identify the main findings, then summarize in 3 bullet points"
+
+4. **Level 4**: Add examples
+   - Include 2-3 example summaries with input-output pairs
+
+### Instruction Hierarchy
+```
+[System Context] → [Task Instruction] → [Examples] → [Input Data] → [Output Format]
+```
+
+### Error Recovery
+Build prompts that gracefully handle failures:
+- Include fallback instructions
+- Request confidence scores
+- Ask for alternative interpretations when uncertain
+- Specify how to indicate missing information
+
+## Best Practices
+
+1. **Be Specific**: Vague prompts produce inconsistent results
+2. **Show, Don't Tell**: Examples are more effective than descriptions
+3. **Test Extensively**: Evaluate on diverse, representative inputs
+4. **Iterate Rapidly**: Small changes can have large impacts
+5. **Monitor Performance**: Track metrics in production
+6. **Version Control**: Treat prompts as code with proper versioning
+7. **Document Intent**: Explain why prompts are structured as they are
+
+## Common Pitfalls
+
+- **Over-engineering**: Starting with complex prompts before trying simple ones
+- **Example pollution**: Using examples that don't match the target task
+- **Context overflow**: Exceeding token limits with excessive examples
+- **Ambiguous instructions**: Leaving room for multiple interpretations
+- **Ignoring edge cases**: Not testing on unusual or boundary inputs
+
+## Integration Patterns
+
+### With RAG Systems
+```python
+# Combine retrieved context with prompt engineering
+prompt = f"""Given the following context:
+{retrieved_context}
+
+{few_shot_examples}
+
+Question: {user_question}
+
+Provide a detailed answer based solely on the context above. If the context doesn't contain enough information, explicitly state what's missing."""
+```
+
+### With Validation
+```python
+# Add self-verification step
+prompt = f"""{main_task_prompt}
+
+After generating your response, verify it meets these criteria:
+1. Answers the question directly
+2. Uses only information from provided context
+3. Cites specific sources
+4. Acknowledges any uncertainty
+
+If verification fails, revise your response."""
+```
+
+## Performance Optimization
+
+### Token Efficiency
+- Remove redundant words and phrases
+- Use abbreviations consistently after first definition
+- Consolidate similar instructions
+- Move stable content to system prompts
+
+### Latency Reduction
+- Minimize prompt length without sacrificing quality
+- Use streaming for long-form outputs
+- Cache common prompt prefixes
+- Batch similar requests when possible
+
+## Resources
+
+- **references/few-shot-learning.md**: Deep dive on example selection and construction
+- **references/chain-of-thought.md**: Advanced reasoning elicitation techniques
+- **references/prompt-optimization.md**: Systematic refinement workflows
+- **references/prompt-templates.md**: Reusable template patterns
+- **references/system-prompts.md**: System-level prompt design
+- **assets/prompt-template-library.md**: Battle-tested prompt templates
+- **assets/few-shot-examples.json**: Curated example datasets
+- **scripts/optimize-prompt.py**: Automated prompt optimization tool
+
+## Success Metrics
+
+Track these KPIs for your prompts:
+- **Accuracy**: Correctness of outputs
+- **Consistency**: Reproducibility across similar inputs
+- **Latency**: Response time (P50, P95, P99)
+- **Token Usage**: Average tokens per request
+- **Success Rate**: Percentage of valid outputs
+- **User Satisfaction**: Ratings and feedback
+
+## Next Steps
+
+1. Review the prompt template library for common patterns
+2. Experiment with few-shot learning for your specific use case
+3. Implement prompt versioning and A/B testing
+4. Set up automated evaluation pipelines
+5. Document your prompt engineering decisions and learnings
+
+## Limitations
+- Use this skill only when the task clearly matches the scope described above.
+- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/skills/global_config/prompt-engineering-patterns/assets/few-shot-examples.json

@@ -0,0 +1,106 @@
+{
+  "sentiment_analysis": [
+    {
+      "input": "This product exceeded my expectations! The quality is outstanding.",
+      "output": "Positive"
+    },
+    {
+      "input": "Terrible experience. The item arrived damaged and customer service was unhelpful.",
+      "output": "Negative"
+    },
+    {
+      "input": "The product works as described. Nothing special, but does the job.",
+      "output": "Neutral"
+    }
+  ],
+  "entity_extraction": [
+    {
+      "input": "Apple CEO Tim Cook announced the new iPhone at an event in Cupertino on September 12th.",
+      "output": {
+        "persons": ["Tim Cook"],
+        "organizations": ["Apple"],
+        "products": ["iPhone"],
+        "locations": ["Cupertino"],
+        "dates": ["September 12th"]
+      }
+    },
+    {
+      "input": "Microsoft acquired GitHub for $7.5 billion in 2018.",
+      "output": {
+        "persons": [],
+        "organizations": ["Microsoft", "GitHub"],
+        "products": [],
+        "locations": [],
+        "dates": ["2018"],
+        "monetary_values": ["$7.5 billion"]
+      }
+    }
+  ],
+  "code_generation": [
+    {
+      "input": "Write a Python function to check if a string is a palindrome",
+      "output": "def is_palindrome(s: str) -> bool:\n    \"\"\"Check if string is palindrome, ignoring case and spaces.\"\"\"\n    # Remove spaces and convert to lowercase\n    cleaned = s.replace(' ', '').lower()\n    # Compare with reversed string\n    return cleaned == cleaned[::-1]"
+    }
+  ],
+  "text_classification": [
+    {
+      "input": "How do I reset my password?",
+      "output": "account_management"
+    },
+    {
+      "input": "My order hasn't arrived yet. Where is it?",
+      "output": "shipping_inquiry"
+    },
+    {
+      "input": "I'd like to cancel my subscription.",
+      "output": "subscription_cancellation"
+    },
+    {
+      "input": "The app keeps crashing when I try to log in.",
+      "output": "technical_support"
+    }
+  ],
+  "data_transformation": [
+    {
+      "input": "John Smith, john@email.com, (555) 123-4567",
+      "output": {
+        "name": "John Smith",
+        "email": "john@email.com",
+        "phone": "(555) 123-4567"
+      }
+    },
+    {
+      "input": "Jane Doe | jane.doe@company.com | +1-555-987-6543",
+      "output": {
+        "name": "Jane Doe",
+        "email": "jane.doe@company.com",
+        "phone": "+1-555-987-6543"
+      }
+    }
+  ],
+  "question_answering": [
+    {
+      "context": "The Eiffel Tower is a wrought-iron lattice tower in Paris, France. It was constructed from 1887 to 1889 and stands 324 meters (1,063 ft) tall.",
+      "question": "When was the Eiffel Tower built?",
+      "answer": "The Eiffel Tower was constructed from 1887 to 1889."
+    },
+    {
+      "context": "Python 3.11 was released on October 24, 2022. It includes performance improvements and new features like exception groups and improved error messages.",
+      "question": "What are the new features in Python 3.11?",
+      "answer": "Python 3.11 includes exception groups, improved error messages, and performance improvements."
+    }
+  ],
+  "summarization": [
+    {
+      "input": "Climate change refers to long-term shifts in global temperatures and weather patterns. While climate change is natural, human activities have been the main driver since the 1800s, primarily due to the burning of fossil fuels like coal, oil and gas which produces heat-trapping greenhouse gases. The consequences include rising sea levels, more extreme weather events, and threats to biodiversity.",
+      "output": "Climate change involves long-term alterations in global temperatures and weather patterns, primarily driven by human fossil fuel consumption since the 1800s, resulting in rising sea levels, extreme weather, and biodiversity threats."
+    }
+  ],
+  "sql_generation": [
+    {
+      "schema": "users (id, name, email, created_at)\norders (id, user_id, total, order_date)",
+      "request": "Find all users who have placed orders totaling more than $1000",
+      "output": "SELECT u.id, u.name, u.email, SUM(o.total) as total_spent\nFROM users u\nJOIN orders o ON u.id = o.user_id\nGROUP BY u.id, u.name, u.email\nHAVING SUM(o.total) > 1000;"
+    }
+  ]
+}