# prompts-chat

> Discovers and applies curated prompts from the prompts.chat collection to optimize AI interactions, prompt engineering, and workflow integration.

- Skill: `akillness/prompts-chat` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds add akillness/prompts-chat`
- Raw SKILL.md: https://api.skillmd.com/api/skills/akillness/prompts-chat/raw
- Safety review: CAUTION (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning, AI & ML, Prompt Engineering
- Tags: Prompt Discovery, Prompt Engineering, Prompt Library, Prompt Templates, Prompt Versioning, Prompts Chat, Workflow Integration
- License: MIT
- Author: akillness (https://skillmd.com/u/akillness)
- Updated: 2026-08-22
- Page: https://skillmd.com/skills/akillness/prompts-chat

---


# prompts-chat — Curated AI Prompt Discovery & Application

Discover and apply high-quality prompts from the prompts.chat collection to enhance AI interactions, workflows, and prompt engineering.

> **Reference**: [prompts.chat](https://github.com/f/prompts.chat) — a community-driven repository of useful prompts for various AI tasks and workflows.

## When to use this skill

- You need a well-crafted prompt template for a specific task or domain
- You're optimizing an AI workflow and want proven prompt patterns
- You're building a prompt library or managing prompt versions
- You want to discover prompts for roles, tasks, or use cases you're unfamiliar with
- You're troubleshooting response quality by refining the prompt structure

## When not to use this skill

- **The main job is building a full LLM application framework** → use `pydantic-ai`, `crewai-multi-agent`, or `langgraph-human-in-the-loop`
- **The main job is prompt optimization via RLHF or fine-tuning** → use `dspy`, `openrlhf-training`, or `moe-training`
- **The main job is building an agent system** → use `deep-agents-core`, `crewai-multi-agent`, or workflow skills like `harness`
- **The main job is RAG pipeline construction** → use `llamaindex` or `supabase-agent-skills`

## Instructions

### Step 1: Classify your prompt need

Identify the category and use case:

```yaml
prompt_need:
  category: writing | coding | analysis | brainstorming | role-play | instruction-tuning | other
  use_case: single-task | template-library | workflow-pipeline | prompt-versioning
  domain: software | marketing | education | science | creative | business | other
  current_pain: quality | consistency | structure | discovery | version-control
```

### Step 2: Fetch and explore prompts.chat data

Access the prompts.chat repository to find relevant prompts:

```bash
# Clone or fetch the latest prompts collection
git clone https://github.com/f/prompts.chat.git /tmp/prompts-chat 2>/dev/null || \
  curl -s https://api.github.com/repos/f/prompts.chat/contents/ | jq '.[] | select(.type=="dir") | .name'

# List available categories
ls /tmp/prompts-chat 2>/dev/null || echo "Use online repository"
```

### Step 3: Evaluate and select prompts

For each candidate prompt, assess:

1. **Relevance**: Does it match your task or domain?
2. **Quality**: Is the prompt structure clear and well-organized?
3. **Adoptability**: Can you integrate it into your workflow without modification?
4. **Reusability**: Does it work as a template for variations?

### Step 4: Adapt prompts to your context

Customize selected prompts:

- Replace placeholders with your specific context
- Adjust tone, length, or output format to fit your workflow
- Test on representative inputs before full deployment
- Document variations and version changes

### Step 5: Store and manage prompt versions

Create a local prompt library for your project:

```bash
# Example structure
prompts/
  ├── approved/
  │   ├── code-review.md
  │   ├── technical-writing.md
  │   └── summarization.md
  ├── drafts/
  └── VERSIONS.md  # Track changes
```

Document:
- Source (prompts.chat or custom)
- Version date
- Intended use case
- Known limitations or tips

### Step 6: Integrate into workflows

Embed prompts into agent workflows:

```bash
# Reference prompt files in scripts
PROMPT=$(cat prompts/approved/technical-writing.md)
curl -s https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -d @- <<EOF
{
  "model": "gpt-4",
  "messages": [{"role": "system", "content": "$PROMPT"}]
}
EOF
```

### Step 7: Monitor and iterate

Track prompt performance:

- Note which prompts yield the best outputs
- Collect feedback from users or automated quality metrics
- Refine based on performance data
- Share improvements back to the community (optional)

## Examples

### Example 1: Finding a code-review prompt

**Goal**: Improve code review quality using a template prompt

```markdown
Search prompts.chat for "code review" or "code analysis" category
→ Find the "Code Review" prompt
→ Adapt it with your repo's standards and style guide
→ Store in `prompts/approved/code-review.md`
→ Use in code review workflows
```

### Example 2: Building a prompt library for content creation

**Goal**: Create consistent content across multiple topics

```markdown
Collect prompts for:
  - SEO-optimized blog post writing
  - Social media caption generation
  - Newsletter content curation
  - Video script structuring
→ Store each in prompts/approved/
→ Version and document in VERSIONS.md
→ Integrate into content pipeline
```

### Example 3: Prompt versioning and A/B testing

**Goal**: Compare prompt effectiveness

```markdown
Create versions:
  - prompts/approved/summarization-v1.md (original)
  - prompts/approved/summarization-v2.md (refined)
→ Test both on sample inputs
→ Measure quality metrics (brevity, accuracy, completeness)
→ Keep best version, document learnings
```

## Best practices

1. **Start with curated sources** — prompts.chat is battle-tested; use it as a foundation
2. **Document your source** — track which prompts come from where and why
3. **Version your prompts** — treat prompts like code; version and track changes
4. **Test before deploying** — validate new or modified prompts on representative inputs
5. **Share learnings** — contribute back to communities like prompts.chat when you improve a prompt
6. **Separate by use case** — organize prompts by domain, role, or task for discoverability
7. **Keep feedback loops** — collect data on which prompts work best and iterate
8. **Avoid prompt bloat** — retire or consolidate underused prompts regularly

## Integration with other skills

- **`dspy`** — Use prompts.chat prompts as seed optimizers for DSPy pipelines
- **`pydantic-ai`** — Embed curated prompts into Pydantic AI agent systems
- **`crewai-multi-agent`** — Structure multi-agent teams with role-specific prompts
- **`llm-wiki`** — Store and version prompts in your durable knowledge base
- **`technical-writing`** — Use prompts to help structure documentation workflows

## References

- [prompts.chat GitHub](https://github.com/f/prompts.chat)
- [OpenAI Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering)
- [Anthropic Prompt Writing Guide](https://docs.anthropic.com/claude/docs/how-to-use-system-prompts)
- [Prompt Engineering Guide (community)](https://www.promptingguide.ai/)