Prompt Engineering
Draft, debug, and optimize LLM prompts—including few-shot sets, chain-of-thought, system prompts, and templates—with testable structure for production agents.
Overview
Prompt Engineering is a journey-wide agent skill that designs, debugs, and optimizes LLM prompts—usable whenever a solo builder needs reliable agent outputs before committing to code or copy.
Install
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill prompt-engineeringWhat is this skill?
- End-to-end workflow: draft, structure, evaluate, and optimize prompts for reliability
- Few-shot selection with reference deep-dive (3–5 examples called out as optimal band)
- Chain-of-thought and reasoning scaffold patterns via targeted reference files
- System prompt and reusable template composition for production use
- Measurable optimization and testing when rewriting underperforming prompts
- 3-5 optimal few-shot example count cited in core patterns
Adoption & trust: 1.2k installs on skills.sh; 271 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent answers are inconsistent, poorly formatted, or weak on reasoning because prompts lack structure, examples, and a repeatable optimization loop.
Who is it for?
Indie devs shipping agent features, custom skills, or production chat flows who want reference-backed prompt patterns in-repo.
Skip if: Teams that only need a single ad-hoc one-liner with no reuse, or work with no LLM in the loop.
When should I use this skill?
User asks to write or improve a prompt, few-shot examples, chain-of-thought, system prompts, templates, or better LLM results.
What do I get? / Deliverables
You leave with improved prompts, optional few-shot and CoT scaffolds, system or template packages, and a path to measurable testing against target outputs.
- Revised or new prompt text
- Few-shot or CoT scaffold
- System prompt or reusable template with evaluation notes
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Structure interview-summary prompts so research agents return consistent fields for competitor notes.
Build few-shot demos for a landing-page chatbot before committing to backend integration.
Author system prompts and templates bundled with a new Cursor or Claude skill.
Tighten review-agent prompts to enforce severity buckets and JSON output for CI checks.
Optimize answer-style prompts for AI-search and FAQ generation without off-brand tone drift.
How it compares
Skill workflow for testable prompt systems—not a hosted prompt playground or an MCP server.
Common Questions / FAQ
Who is prompt-engineering for?
Solo builders and small teams building or tuning LLM-powered agents, skills, and automated workflows in their repos.
When should I use prompt-engineering?
At Build when authoring agent skills; during Validate prototypes for LLM demos; at Ship review when fixing format regressions; at Launch for GEO/SEO agent copy; and anytime you rewrite or optimize a system prompt.
Is prompt-engineering safe to install?
It may use shell and file edits for local prompt files; review the Security Audits panel on this Prism page and restrict Bash scope in untrusted environments.
SKILL.md
READMESKILL.md - Prompt Engineering
# Prompt Engineering ## Overview Use this skill to design prompt systems that are clear, testable, and reusable. It covers prompt drafting, optimization, evaluation, and production-oriented patterns for few-shot prompting, reasoning workflows, templates, and system prompts. Keep the main workflow in this file and load the targeted reference files only for the pattern you are applying. ## When to Use Use this skill when: - A user asks to write, rewrite, or improve a prompt - A prompt needs better structure, reliability, or output formatting - Few-shot examples or reasoning scaffolds are needed - A system prompt or reusable prompt template must be created - An existing prompt needs measurable optimization and testing Read the relevant files in `references/` when you need deeper guidance on a specific pattern. ## Core Patterns ### 1. Few-Shot Learning #### Example Selection Strategy - Use `references/few-shot-patterns.md` for comprehensive selection frameworks - Balance example count (3-5 optimal) with context window limitations - Include edge cases and boundary conditions in example sets - Prioritize diverse examples that cover problem space variations - Order examples from simple to complex for progressive learning #### Few-Shot Example (Sentiment Classification) ``` Classify the sentiment as Positive, Negative, or Neutral. Text: "I love this product! It exceeded my expectations." Sentiment: Positive Reasoning: Enthusiastic language, positive adjectives, satisfaction Text: "The app keeps crashing when I upload large files." Sentiment: Negative Reasoning: Complaint about functionality, frustration indicator Text: "It arrived on time, as described." Sentiment: Neutral Reasoning: Factual statement, no strong emotion either way Text: "{user_input}" Sentiment: Reasoning: ``` ### 2. Chain-of-Thought Reasoning #### Implementation Patterns - Reference `references/cot-patterns.md` for detailed reasoning frameworks - Use "Let's think step by step" for zero-shot CoT initiation - Provide complete reasoning traces for few-shot CoT demonstrations - Implement self-consistency by sampling multiple reasoning paths - Include verification and validation steps in reasoning chains #### CoT Template Structure ``` Let's approach this step-by-step: Step 1: {break_down_the_problem} Analysis: {detailed_reasoning} Step 2: {identify_key_components} Analysis: {component_analysis} Step 3: {synthesize_solution} Analysis: {solution_justification} Final Answer: {conclusion_with_confidence} ``` ### 3. Prompt Optimization #### Optimization Process - Use `references/optimization-frameworks.md` for comprehensive optimization strategies - Measure baseline performance before optimization attempts - Implement single-variable changes for accurate attribution - Track metrics: accuracy, consistency, latency, token efficiency - Use statistical significance testing for A/B validation - Document optimization iterations and their impacts Track these metrics: accuracy, consistency, token efficiency, robustness, safety. See `references/optimization-frameworks.md` for measurement utilities. ### 4. Template Systems #### Template Design Principles - Reference `references/template-systems.md` for modular template frameworks - Use clear variable naming conventions (e.g., `{user_input}`, `{context}`) - Implement conditional sections for different scenario handling - Design role-based templates for specific use cases - Create hierarchical template composition patterns #### Template St