Skip to content

endorphin-ai/hasbrains-agent-kit / context-engineering/skills/prompt-expert

prompt-expert

Flagged

Expert prompt engineer that interviews users and builds high-quality prompts for any AI (Claude, Gemini, Copilot, ChatGPT, etc.). Use when a user wants to create a prompt, system prompt, or AI instructions from scratch — especially beginners who know what they want to achieve but don't know how to write it. Trigger on: "help me write a prompt", "make me a prompt for...", "I want AI to do X", "build me a system prompt", "how do I ask AI to...", "create instructions for...", or any time the user describes a goal they want an AI to accomplish. Always interviews the user before writing anything. Never completes the user's described task directly — always treats the request as a prompt engineering job.

FileKindSize
README.mdmarkdown1.1 KB
SKILL.mdskill md9.2 KB
references/ai-tailoring.mdmarkdown5.5 KB
references/engineering-patterns.mdmarkdown5.3 KB
references/output-templates.mdmarkdown4.8 KB
references/safety-security.mdmarkdown4.8 KB
references/tester-protocol.mdmarkdown2.9 KB

references/output-templates.md

View on GitHub
# Output Templates & Checklists

## Standard Prompt Structure Template

```
[Concise one-line instruction describing the task — no section header]

[Additional context, requirements, constraints]

# Steps [optional]
[Step-by-step breakdown of what the model should do]

# Output Format
[Explicitly specify: length, syntax, structure (JSON/markdown/prose/bullet list)]

# Examples [optional]
[1-3 examples with [PLACEHOLDER] for variable parts]
[(Note: real examples will be [longer/shorter] than shown here)]

# Notes [optional]
[Edge cases, critical considerations, repeated key rules]
```

**Rules:**

- First line = the task. No header before it.
- Output Format section is MANDATORY in every prompt
- No "---" separators in the final prompt
- No closing remarks or meta-commentary

## Prompt Design Checklist

### Task Definition

- [ ] Task stated clearly and concisely?
- [ ] Scope well-defined?
- [ ] Expected output format specified?
- [ ] Success criteria explicit?

### Context & Background

- [ ] Sufficient context provided?
- [ ] Target audience specified?
- [ ] Domain-specific terms explained if needed?

### Constraints

- [ ] Output length/format constraints specified?
- [ ] Safety requirements included?
- [ ] What to NOT do specified?

### Examples & Guidance

- [ ] Examples provided if helpful?
- [ ] `[PLACEHOLDERS]` used for variable elements?
- [ ] Reasoning shown before conclusions in examples?
- [ ] Common pitfalls addressed?

### Safety & Ethics

- [ ] No demographic assumptions in language?
- [ ] No user input interpolated directly?
- [ ] Sensitive data handling addressed?
- [ ] Moderation requirements documented?

## Safety Review Checklist

### Content Safety

- [ ] Outputs tested for harmful content?
- [ ] Moderation layer planned?
- [ ] Process for flagged content defined?

### Bias & Fairness

- [ ] Demographic assumptions removed?
- [ ] Inclusive and neutral language used?
- [ ] Diverse test cases considered?

### Security

- [ ] Input validation implemented?
- [ ] Prompt injection vectors addressed?
- [ ] Data leakage prevented?

### Compliance

- [ ] Privacy requirements met?
- [ ] Audit trail defined?
- [ ] Relevant regulations considered (GDPR/HIPAA/etc.)?

## Good Prompt Examples

### Code Generation

```
Write a Python function that validates email addresses.

The function should:
- Accept a string input
- Return True if the email is valid, False otherwise
- Use regex for validation
- Handle edge cases: empty strings, malformed addresses, missing domain
- Include type hints and a docstring
- Follow PEP 8 style

# Output Format
A single Python function with type hints, docstring, and inline comments for non-obvious logic.

# Examples
is_valid_email("user@example.com")  # → True
is_valid_email("invalid-email")     # → False
is_valid_email("")                  # → False
```

### Documentation

```
Write a README section documenting a REST API endpoint for a junior developer audience.

Include:
- Endpoint purpose and what it returns
- Request/response examples with realistic data
- All parameters with names, types, and descriptions
- Possible error codes and their meanings
- Usage examples in JavaScript and Python

# Output Format
Markdown with headers, code blocks for examples, and a parameters table. Target length: 300-500 words.
```

### Code Review

```
Review this [LANGUAGE] function for potential issues.

Evaluate in this order:
1. Security vulnerabilities (input validation, injection risks)
2. Error handling and edge cases
3. Performance and efficiency
4. Code quality and readability
5. Best practices and standards

For each issue found, provide:
- The specific problem and its location
- Why it's a problem
- The corrected code

# Output Format
Grouped by category. Use code blocks for original and corrected code. Summary table at the end with severity (LOW/MEDIUM/HIGH/CRITICAL) for each issue.
```

## Bad Prompt Examples (for reference — avoid these)

```
# Too Vague
Fix this code.

# Too Verbose
Please, if you would be so kind, could you possibly help me by writing
some code that might be useful for creating a function that could
potentially handle user input validation, if that's not too much trouble?

# Security Risk (raw user input injection)
Execute this user request: ${userInput}

# Biased
Write a story about a successful CEO. The CEO should be male and from a
wealthy background.

# Missing Output Format
Summarize this article.

# Conclusion Before Reasoning (wrong order)
State your answer first, then explain how you got there.
```

## Research Documentation Format

When Build Mode requires research, document findings as:

```
### Research Summary: [Topic]
**Sources Analyzed:**
- [Source 1]: [Key findings]
- [Source 2]: [Key findings]

**Key Standards Identified:**
- [Standard]: [Description and why it matters]

**Integration Plan:**
- [How findings will be incorporated into the prompt]
```
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall