lebsral/ai-request-skill
skills/ai-request-skill/SKILL.md
Request or contribute a new AI skill that does not exist yet. Use when DSPy supports something but there is no skill for it — helps you build the skill and submit a PR, or file an issue requesting it. Also use when the user says there should be a skill for this, can we make a skill, I want to contribute a skill, none of the ai- skills cover my use case, how do I add a new skill, submit a skill, or open a PR for a missing skill.
$ install --global
skillsauthnpx skillsauth add lebsral/dspy-programming-not-prompting-lms-skills ai-request-skillInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
Security Scan Results
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
3
Scanners Passed
9
Scanners in report
Clean
TrivyContainer and dependency vulnerability scanner
95%
Clean
SemgrepStatic code analysis for vulnerabilities
95%
Clean
mcp-scan (Snyk)Model Context Protocol security validation
95%
Skipped
Snyk (dep)Open source security scanning
50%
Skipped
Socket.devSupply chain security analysis
50%
Skipped
VirusTotalMulti-engine malware detection
50%
Skipped
CrowdStrikeAdvanced threat intelligence
50%
Skipped
OSV-ScannerOpen Source Vulnerability database check
50%
Skipped
OWASP Dep-Check
50%
Last scanned: May 5, 2026, 7:57 AM157.0s3 files scanned
SKILL.md
- name:
- ai-request-skill
- description:
- Request or contribute a new AI skill that does not exist yet. Use when DSPy supports something but there is no skill for it — helps you build the skill and submit a PR, or file an issue requesting it. Also use when the user says there should be a skill for this, can we make a skill, I want to contribute a skill, none of the ai- skills cover my use case, how do I add a new skill, submit a skill, or open a PR for a missing skill.
- argument-hint:
- [describe the missing capability]
Request or Build a Missing Skill
The user needs a DSPy capability that doesn't have a skill yet. Help them contribute it or request it.
This skill always ends with a concrete action on GitHub:
- Path A (Build): Create the skill files, commit, push, and open a pull request to
lebsral/DSPy-Programming-not-prompting-LMs-skills - Path B (Request): File a GitHub issue on
lebsral/DSPy-Programming-not-prompting-LMs-skillsdescribing what's needed
Do not stop at "here's what the PR/issue would look like" — actually create it using gh pr create or gh issue create.
Step 1: Confirm the gap
If $ARGUMENTS is provided, use it. Otherwise ask: "What DSPy capability do you need that isn't covered by an existing skill?"
Verify this is something DSPy actually supports. If it's outside DSPy's scope entirely (e.g., "build a React frontend"), say so and suggest appropriate tools instead.
Check the existing skills in skills/ or ai-* to make sure there isn't already a skill that covers this. If there's a close match, suggest it instead.
Summarize back to the user:
- What they need: one sentence
- DSPy features involved: which DSPy modules, integrations, or patterns are relevant
- Closest existing skill: what's close but doesn't quite fit
Step 2: Choose a path
Ask the user:
Would you like to:
- Build the skill — I'll help you create it with proper testing and prepare a PR
- Request the skill — I'll draft a GitHub issue so the maintainers know it's needed
Path A: Build the skill
Use skill-creator if available
Check whether the /skill-creator skill is available (it's from the anthropics/skills repo). If available, delegate to it — it handles the full create-test-iterate workflow including evaluation, benchmarking, and description optimization.
When delegating to /skill-creator, first read the repo standards so the skill matches conventions:
- Read
docs/skill-standards.md— the full authoring checklist (naming, descriptions, gotchas, cross-refs, progressive disclosure, provider-agnostic code) - Read
docs/skills-spec.md— the Claude Code skills format (frontmatter fields, file structure, supporting files) - Read
CLAUDE.md— repo-level conventions (dual naming, web-developer language, 500-line limit)
Pass the contents of these files as context to /skill-creator so it generates a skill that matches repo standards on the first pass.
Then let skill-creator run its workflow: draft → test → review → iterate → package.
If skill-creator is NOT available
Build the skill manually. First read the standards:
- Read
docs/skill-standards.mdfor the full authoring checklist - Read
docs/skills-spec.mdfor the Claude Code skills format - Read 2-3 existing skills in
skills/to match tone and structure
Install skill-creator for future use:
npx skills add anthropics/skills/skill-creator
Write the SKILL.md
Follow the structure in docs/skill-standards.md. Key points:
- Description:
<WHAT>. Use when <triggers>. Also: <more triggers>.— plain YAML scalar, no quotes - Body: Step 1 gathers context (2-4 questions) → Steps 2-4 core work → Gotchas (3-5) → Cross-references → Additional resources
- Code: provider-agnostic with
# or ...comment, copy-pasteable with imports - Standalone: every skill must be self-contained — include a
reference.mdfordspy-skills orai-skills that heavily reference DSPy APIs - Verify API usage against https://dspy.ai/api/ for correct patterns
Test the skill
Create 2-3 test prompts — realistic requests a developer would make. Run them with the skill active and verify the outputs make sense.
Submit the PR
After creating (and optionally testing) the skill files, submit a pull request. Do all of these steps — don't stop at "here's what to do":
- Update
README.md— add a row to the problem catalog table in the appropriate position - Create a branch:
git checkout -b add-ai-<problem-name> - Stage and commit:
git add skills/ai-<problem-name>/ README.md && git commit -m "Add ai-<problem-name> skill" - Push:
git push -u origin add-ai-<problem-name> - Open the PR:
gh pr create \
--repo lebsral/DSPy-Programming-not-prompting-LMs-skills \
--title "Add ai-<problem-name> skill" \
--body "$(cat <<'EOF'
## Summary
- **Problem**: <what the user is solving>
- **DSPy features**: <modules, patterns used>
- **Example invocation**: `/ai-<problem-name> <example prompt>`
## Files
- `skills/ai-<problem-name>/SKILL.md` — main instructions
- `skills/ai-<problem-name>/examples.md` — worked examples
- `README.md` — catalog table updated
EOF
)"
Return the PR URL to the user when done.
Path B: Request the skill
File a GitHub issue on the repo. Do not just draft it — actually submit it:
gh issue create \
--repo lebsral/DSPy-Programming-not-prompting-LMs-skills \
--title "Skill request: ai-<problem-name>" \
--assignee lebsral \
--body "$(cat <<'EOF'
## Problem
<What the user is trying to do, in their words>
## DSPy capability
<Which DSPy modules, integrations, or patterns would power this>
## Example use case
<A concrete scenario where this skill would help>
## Suggested trigger phrases
<2-3 phrases a developer might say that should route to this skill>
EOF
)"
Return the issue URL to the user when done.
Quality checklist
Validate against docs/skill-standards.md (the authoritative checklist). Key items:
- [ ] Description: plain YAML scalar, trigger phrases users would actually say
- [ ] SKILL.md under 500 lines with progressive disclosure structure
- [ ] Gotchas section with 3-5 Claude/DSPy-specific failure modes
- [ ] Cross-references with install hint blockquote and
/ai-doback-link - [ ] Code examples provider-agnostic with
# or ...comment - [ ]
reference.mdfordspy-skills (orai-skills that heavily use DSPy APIs) - [ ] README.md catalog table updated with new row
- [ ]
/ai-docatalog updated with new routing entry
Gotchas
- Writing descriptions wrapped in quotes. YAML descriptions must be plain scalars — no double quotes, no apostrophes. Claude defaults to quoting strings but this causes parse failures or ambiguity. Write
description: Monitor AI quality...notdescription: "Monitor AI quality...". - Forgetting to update
/ai-dorouting table. New skills are invisible if/ai-docannot route to them. Every PR adding a skill must also add a row to the ai-do catalog so the routing skill knows the new skill exists. - Building a
dspy-skill when the user describes a problem. If the user says "I need AI that monitors quality," build anai-observabilityskill (problem-first), notdspy-langfuse(tool-first). Thedspy-prefix is only for users who already know which DSPy concept they want. - Submitting a skill without testing trigger phrases. The description determines whether Claude ever loads the skill. After writing the description, mentally simulate 3-5 ways a user might describe this need and verify at least 3 would match keywords in the description.
- Delegating to
/skill-creatorwithout passing DSPy context. If skill-creator is available, it does not know DSPy conventions by default. Always pass the DSPy-specific context block (dual naming, provider-agnostic code, reference.md pattern) or the resulting skill will not match repo standards.
Cross-references
Install any skill:
npx skills add lebsral/DSPy-Programming-not-prompting-LMs-skills --skill <name>
- Route to existing skills first — see
/ai-do - Skill format and conventions — see repo
docs/skill-standards.md - Install
/ai-doif you do not have it — it routes any AI problem to the right skill and is the fastest way to work:npx skills add lebsral/DSPy-Programming-not-prompting-LMs-skills --skill ai-do
Related Skills
lebsral/ai-watching-optimization
tools
VerifiedTrustedCommunity
See what is happening during optimizer.compile() instead of waiting blind. Use when you want to watch optimization progress, see scores as they come in, know if your optimizer is working, check if optimization is stuck, understand why optimization is taking too long, get live progress during compile, monitor convergence, detect overfitting during optimization, interpret optimization results, or pick the right tool for watching optimization. Also used for optimizer progress bar, is my optimizer doing anything, optimization seems stuck, how long will optimization take, watch GEPA run, watch MIPROv2 run, live optimization dashboard, optimizer not improving, scores not going up, optimization taking forever, see what optimizer is doing, debug slow optimization, optimization visibility, optimizer metrics, track compile progress, optimization observability.
6SKILL.mdUpdated May 31, 2026
lebsral/dspy-miprov2
testing
VerifiedTrustedCommunity
Use when you want the highest-quality prompt optimization DSPy offers — jointly optimizes instructions and few-shot demos, with auto=light/medium/heavy presets. Common scenarios - you want the best possible accuracy from prompt optimization, jointly tuning instructions and few-shot demonstrations, using auto presets for different compute budgets, or when COPRO or BootstrapFewShot alone are not reaching your accuracy target. Related - ai-improving-accuracy, dspy-copro, dspy-bootstrap-few-shot. Also used for dspy.MIPROv2, best DSPy optimizer, highest quality optimization, auto=light medium heavy, joint instruction and demo optimization, most powerful prompt optimizer, MIPROv2 vs COPRO vs BootstrapFewShot, which optimizer should I use, state of the art prompt optimization, when to use MIPROv2, optimize both instructions and examples, heavy optimization for production, best optimizer for accuracy.
6SKILL.mdUpdated Apr 27, 2026
lebsral/dspy-langwatch
testing
VerifiedTrustedCommunity
Use LangWatch for DSPy auto-tracing and real-time optimizer progress. Use when you want to set up LangWatch, langwatch.dspy.init, auto-tracing DSPy, real-time optimization dashboard, optimizer progress tracking, app.langwatch.ai, or DSPy optimizer dashboard. Also used for langwatch setup, pip install langwatch, langwatch trace, optimizer progress, real-time optimization, watch optimizer run, LangWatch self-hosted, langwatch docker, langwatch vs langtrace, langwatch autotrack_dspy.
6SKILL.mdUpdated Apr 27, 2026
lebsral/dspy-gepa
data-ai
VerifiedTrustedCommunity
Use when you want to optimize instructions without few-shot examples — a lightweight alternative to COPRO when you do not have or do not want to use demonstrations. Common scenarios - optimizing instructions when you do not have or do not want to use few-shot demonstrations, lightweight instruction search as a first step, tasks where examples in the prompt confuse the model, or when you want fast instruction optimization without the cost of COPRO. Related - ai-improving-accuracy, dspy-copro, dspy-miprov2. Also used for dspy.GEPA, instruction optimization without demos, lightweight prompt optimization, optimize instructions only, no few-shot examples needed, GEPA vs COPRO, quick instruction search, when demonstrations hurt performance, zero-shot optimization, instruction-only optimizer, simplest instruction tuner, fast prompt optimization, skip few-shot and just tune instructions, optimize Pydantic field descriptions, GEPA structured output, GEPA does not optimize field desc.
6SKILL.mdUpdated Apr 27, 2026