What it does
Use this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates.
Skills ZICQ category:Design prompt-engineering
Use this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates.
Official URL:skills.sh
Intro in this page language first. The official description stays in its original wording; we do not rewrite SKILL.md.
Use this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates.
you need consistent formatting, specific reasoning patterns, or handling of edge cases. More examples improve accuracy but consume tokens—balance based on task complexity
Per Agent Skills progressive disclosure: name and description load at startup (~100 tokens); the full SKILL.md body loads when the skill activates; scripts/, references/, and assets/ load only as needed. This file's sections: Prompt Engineering Patterns; Core Capabilities; 1. Few-Shot Learning; 2. Chain-of-Thought Prompting; 3. Prompt Optimization; 4. Template Systems.
File analysis: besides SKILL.md, the body references scripts/migrate.py. Those resources load on demand. The body is about 554 lines, above the spec’s 500-line guidance; agents still load it in full on activation.
Prompt Engineering PatternsCore Capabilities1. Few-Shot Learning2. Chain-of-Thought Prompting3. Prompt Optimization4. Template SystemsReusable code review templateUsage5. System Prompt DesignKey PatternsProgressive DisclosureInstruction Hierarchy
Source category:skills.sh agent-skill
nameprompt-engineeringdescriptionscripts/migrate.pyThese paths are extracted from the text. Check the upstream package to verify the files exist.
Invocation syntax and available tools depend on your Agent client. Client integration guide ↗
Choose the target agent and installation scope, keep referenced package files, then verify the skill appears in the client's catalog.
This skill references supporting files. Retrieve the complete directory from the source; copying SKILL.md alone may leave missing dependencies.
Copy these instructions to a compatible agent and confirm the target directory matches your client.
Install the agent skill "prompt-engineering" into my project. The full SKILL.md and official description are at https://zicq.com/en/skills/skl-ce8cc6b611d2fb2b-Prompt-Engineering.html Save it as .cursor/skills/prompt-engineering/SKILL.md or .claude/skills/prompt-engineering/SKILL.md and keep the frontmatter name and description exactly as-is. This skill also ships scripts/, references/, or assets/ — fetch the whole folder from https://github.com/neolabhq/context-engineering-kit instead of creating only a SKILL.md.
Requires Node.js and npx. First inspect the repository's skill list to confirm the name.
npx skills add 'https://github.com/neolabhq/context-engineering-kit' --list
npx skills add 'https://github.com/neolabhq/context-engineering-kit' --skill 'prompt-engineering'
The CLI lets you choose the agent interactively. The default scope is the project; use -g for user scope. Confirm package availability with the discovery command, then use npx skills list to inspect installed skills.
Advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability.
Teach the model by showing examples instead of explaining rules. Include 2-5 input-output pairs that demonstrate the desired behavior. Use when you need consistent formatting, specific reasoning patterns, or handling of edge cases. More examples improve accuracy but consume tokens—balance based on task complexity.
Example:
Extract key information from support tickets:
Input: "My login doesn't work and I keep getting error 403"
Output: {"issue": "authentication", "error_code": "403", "priority": "high"}
Input: "Feature request: add dark mode to settings"
Output: {"issue": "feature_request", "error_code": null, "priority": "low"}
Now process: "Can't upload files larger than 10MB, getting timeout"
Request step-by-step reasoning before the final answer. Add "Let's think step by step" (zero-shot) or include example reasoning traces (few-shot). Use for complex problems requiring multi-step logic, mathematical reasoning, or when you need to verify the model's thought process. Improves accuracy on analytical tasks by 30-50%.
Example:
Analyze this bug report and determine root cause.
Think step by step:
1. What is the expected behavior?
2. What is the actual behavior?
3. What changed recently that could cause this?
4. What components are involved?
5. What is the most likely root cause?
Bug: "Users can't save drafts after the cache update deployed yesterday"
Systematically improve prompts through testing and refinement. Start simple, measure performance (accuracy, consistency, token usage), then iterate. Test on diverse inputs including edge cases. Use A/B testing to compare variations. Critical for production prompts where consistency and cost matter.
Example:
Version 1 (Simple): "Summarize this article"
→ Result: Inconsistent length, misses key points
Version 2 (Add constraints): "Summarize in 3 bullet points"
→ Result: Better structure, but still misses nuance
Version 3 (Add reasoning): "Identify the 3 main findings, then summarize each"
→ Result: Consistent, accurate, captures key information
Build reusable prompt structures with variables, conditional sections, and modular components. Use for multi-turn conversations, role-based interactions, or when the same pattern applies to different inputs. Reduces duplication and ensures consistency across similar tasks.
Example:
# Reusable code review template
template = """
Review this {language} code for {focus_area}.
Code:
{code_block}
Provide feedback on:
{checklist}
"""
# Usage
prompt = template.format(
language="Python",
focus_area="security vulnerabilities",
code_block=user_code,
checklist="1. SQL injection\n2. XSS risks\n3. Authentication"
)
Set global behavior and constraints that persist across the conversation. Define the model's role, expertise level, output format, and safety guidelines. Use system prompts for stable instructions that shouldn't change turn-to-turn, freeing up user message tokens for variable content.
Example:
System: You are a senior backend engineer specializing in API design.
Rules:
- Always consider scalability and performance
- Suggest RESTful patterns by default
- Flag security concerns immediately
- Provide code examples in Python
- Use early return pattern
Format responses as:
1. Analysis
2. Recommendation
3. Code example
4. Trade-offs
Start with simple prompts, add complexity only when needed:
Level 1: Direct instruction
Level 2: Add constraints
Level 3: Add reasoning
Level 4: Add examples
[System Context] → [Task Instruction] → [Examples] → [Input Data] → [Output Format]
Build prompts that gracefully handle failures:
# 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."""
# 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."""
Based on Anthropic's official best practices for agent prompting.
The “context window” refers to the entirety of the amount of text a language model can look back on and reference when generating new text plus the new text it generates. This is different from the large corpus of data the language model was trained on, and instead represents a “working memory” for the model. A larger context window allows the model to understand and respond to more complex and lengthy prompts, while a smaller context window may limit the model’s ability to handle longer prompts or maintain coherence over extended conversations.
The context window is a public good. Your prompt, command, skill shares the context window with everything else Claude needs to know, including:
Default assumption: Claude is already very smart
Only add context Claude doesn't already have. Challenge each piece of information:
Good example: Concise (approximately 50 tokens):
## Extract PDF text
Use pdfplumber for text extraction:
```python
import pdfplumber
with pdfplumber.open("file.pdf") as pdf:
text = pdf.pages[0].extract_text()
```
Bad example: Too verbose (approximately 150 tokens):
## Extract PDF text
PDF (Portable Document Format) files are a common file format that contains
text, images, and other content. To extract text from a PDF, you'll need to
use a library. There are many libraries available for PDF processing, but we
recommend pdfplumber because it's easy to use and handles most cases well.
First, you'll need to install it using pip. Then you can use the code below...
The concise version assumes Claude knows what PDFs are and how libraries work.
Match the level of specificity to the task's fragility and variability.
High freedom (text-based instructions):
Use when:
Example:
## Code review process
1. Analyze the code structure and organization
2. Check for potential bugs or edge cases
3. Suggest improvements for readability and maintainability
4. Verify adherence to project conventions
Medium freedom (pseudocode or scripts with parameters):
Use when:
Example:
## Generate report
Use this template and customize as needed:
```python
def generate_report(data, format="markdown", include_charts=True):
# Process data
# Generate output in specified format
# Optionally include visualizations
```
Low freedom (specific scripts, few or no parameters):
Use when:
Example:
## Database migration
Run exactly this script:
```bash
python scripts/migrate.py --verify --backup
```
Do not modify the command or add additional flags.
Analogy: Think of Claude as a robot exploring a path:
Usefull for writing prompts, including but not limited to: commands, hooks, skills for Claude Code, or prompts for sub agents or any other LLM interaction.
LLMs respond to the same persuasion principles as humans. Understanding this psychology helps you design more effective skills - not to manipulate, but to ensure critical practices are followed even under pressure.
Research foundation: Meincke et al. (2025) tested 7 persuasion principles with N=28,000 AI conversations. Persuasion techniques more than doubled compliance rates (33% → 72%, p < .001).
What it is: Deference to expertise, credentials, or official sources.
How it works in prompts:
When to use:
Example:
✅ Write code before test? Delete it. Start over. No exceptions.
❌ Consider writing tests first when feasible.
What it is: Consistency with prior actions, statements, or public declarations.
How it works in prompts:
When to use:
Example:
✅ When you find a skill, you MUST announce: "I'm using [Skill Name]"
❌ Consider letting your partner know which skill you're using.
What it is: Urgency from time limits or limited availability.
How it works in prompts:
When to use:
Example:
✅ After completing a task, IMMEDIATELY request code review before proceeding.
❌ You can review code when convenient.
What it is: Conformity to what others do or what's considered normal.
How it works in prompts:
When to use:
Example:
✅ Checklists without TodoWrite tracking = steps get skipped. Every time.
❌ Some people find TodoWrite helpful for checklists.
What it is: Shared identity, "we-ness", in-group belonging.
How it works in prompts:
When to use:
Example:
✅ We're colleagues working together. I need your honest technical judgment.
❌ You should probably tell me if I'm wrong.
What it is: Obligation to return benefits received.
How it works:
When to avoid:
What it is: Preference for cooperating with those we like.
How it works:
When to avoid:
| Prompt Type | Use | Avoid | |------------|-----|-------| | Discipline-enforcing | Authority + Commitment + Social Proof | Liking, Reciprocity | | Guidance/technique | Moderate Authority + Unity | Heavy authority | | Collaborative | Unity + Commitment | Authority, Liking | | Reference | Clarity only | All persuasion |
Bright-line rules reduce rationalization:
Implementation intentions create automatic behavior:
LLMs are parahuman:
Legitimate:
Illegitimate:
The test: Would this technique serve the user's genuine interests if they fully understood it?
When designing a prompt, ask:
Design
Design and implement automation workflows to save time and scale operations as a solopreneur. Use when identifying repetitive tasks to autom…
Design
UI/UX design intelligence and implementation guidance for building polished interfaces. Use when the user asks for UI design, UX flows, info…
Design
Expert frontend design guidelines for creating beautiful, modern UIs. Use when building landing pages, dashboards, or any user interface.
Design
Designs and outputs n8n workflow JSON with robust triggers, idempotency, error handling, logging, retries, and human-in-the-loop review queu…