agentleFS
LeonardSEOLeonardSEO/prompt-engineer-skill/SKILL.md

prompt-engineer

Skill2 starsChanged 4 days agoMITView on GitHub

Write, improve, or critique LLM prompts and agent instructions. Use when the prompt itself is the deliverable.

77 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use idea-validator, debugger and 8 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • dipaulavsSkill

    idea-validator

    Validates app ideas before building. Analyzes market saturation, competitors, real demand vs stated interest, solo builder feasibility (2-4 weeks timeline), and monetization potential. Use when user asks to validate an idea, evaluate a concept, check if idea is worth building, or before starting a new project.

    Also in 3 projects that use this

  • JohnJBorenSkill

    debugger

    Systematic debugging workflows, root cause analysis, and troubleshooting patterns

    Also in 3 projects that use this

  • VercelSkill

    technical-writer

    Write, review, and edit developer documentation for SDKs, libraries, and frameworks, including sites such as ai-sdk.dev and chat-sdk.dev. Use for getting-started guides, tutorials, API references, conceptual explanations, integration guides, migration guides, troubleshooting, and code examples.

    Also in 3 projects that use this

  • JetBrainsSkill

    webapp-testing

    Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

    Also in 4 projects that use this

  • JetBrainsSkill

    doc-coauthoring

    Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.

    Also in 3 projects that use this

  • MicrosoftSkill

    api-design

    Guide for designing and documenting RESTful APIs. Use when asked to design an API, create endpoints, or document an API.

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 6 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 67 edited versions we read keep these.

  • 6

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Write prompts that make the intended result, relevant context, and limits clear.

    line 10
  2. Distinctive:

    Reasoning: Never ask for hidden chain-of-thought.

    line 33
  3. Distinctive:

    Use calm, direct instructions with concrete verbs.

    line 42
  4. Distinctive:

    Write connected, complete sentences in familiar language.

    line 44
  5. Distinctive:

    Add model-specific mitigations for a relevant behavior, not as a universal bundle.

    line 72
  6. Distinctive:

    Use this order as a starting point, keeping only the blocks that contribute useful information:

    line 78

“Common” is measured: kept by at least 6 in 10 of the 67 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Prompt Engineer

Overview

Write prompts that make the intended result, relevant context, and limits clear. Improve the prompt for its actual task and target model; a longer prompt is not inherently a better prompt.

Workflow

  1. Improve an existing prompt → preserve intent and working parts; fix demonstrated weaknesses.
  2. Create a new prompt → if the goal is clear enough, write it directly.
  3. Goal unclear → use available context first; ask a focused question if different answers would materially change the result.
  4. Critique → report concrete issues; rewrite only when requested or useful to illustrate a fix.

Identify the intended deliverable, audience, target model/version, destination, and any required output contract from the request. Ask only for missing information that matters; don't turn this into an intake questionnaire. When the model is unspecified, write a portable prompt.

For improvements, identify the weakness and its likely effect before editing: ambiguity, missing context, conflicting rules, unsupported claims, scope drift, poor readability, or premature stopping. Fix what applies. If the prompt already works, keep the useful parts. When there's a tradeoff, give one clear recommendation and its material limitation.

Core rules

  • Preserve intent — keep the meaning, scope, permissions, and required interfaces. Preserve working formatting unless changing it improves usability. Flag contradictions or unsupported assumptions rather than silently changing requirements. Explicit user requirements override this skill's defaults, subject to higher-priority instructions.
  • Outcome first. Define what good output looks like before prescribing process; let the model choose the path unless every step truly matters.
  • Separate control layers. Prompt text steers behavior; API configuration controls supported effort, token limits, and output features; the harness runs tools, renders updates, and manages continuation. Diagnose which layer needs changing. Don't claim prose can enable a capability or repair a client that discards model output.
  • Observable behavior over vibes — replace "be smart"/"think deeply" with success criteria, checks, or output requirements.
  • Decision rules over blanket rules. Reserve always/never/must/only for true invariants. For judgment calls (when to ask, use a tool, keep iterating), give a rule for deciding.
  • Context engineering. Separate instructions, input, background, source material, and output requirements — include only what could change the answer. Use labeled sections or tags when they clarify boundaries; treat quoted source material as data, not instructions.
  • Grounding, when facts/research/advice are involved: define relevant evidence and source boundaries; require citations or source identifiers when the reader needs to verify claims. Distinguish findings, assumptions, and recommendations; specify how to handle missing or conflicting evidence. Don't invent facts, citations, or capabilities.
  • Tools/agents, when the prompt drives actions: define available capabilities, authorization boundaries, completion criteria, and what to do when required evidence is unavailable. A prompt cannot grant tools or permissions the runtime does not provide.
  • Reasoning. Never ask for hidden chain-of-thought; ask for a short rationale, assumptions, or a verification check instead.
  • Structured output. Define format exactly (fields, order, allowed values, length) when it matters — don't rely on examples alone for a schema.
  • Examples, only when they resolve a concrete ambiguity or teach a required pattern; use the fewest useful examples and keep their scope consistent. Show the desired answer style or decision, not hidden reasoning. Avoid examples that imply a narrower task than intended.
  • Ambiguity. Proceed on reasonable assumptions when still useful; state assumptions briefly if they matter; ask only when truly blocked.

Wording and voice

Apply these defaults to your explanations and to prompts you write when they fit the requested output. Preserve the user's language, audience, brand voice, and genre; do not force conversational prose onto code, JSON, poetry, or another required format.

  • Use calm, direct instructions with concrete verbs. Prefer a positive description of the desired result. Add a prohibition when it prevents a specific failure; pair it with the preferred behavior where useful.
  • State the main answer or requested action early. Give the context needed to understand it, then the supporting detail. Final reports should make sense to someone who did not see earlier messages or tool calls.
  • Write connected, complete sentences in familiar language. Use consistent terms and define necessary jargon. Use paragraphs for related ideas, lists for separate items, and tables for comparisons.
  • Make concision a choice about what matters. Remove filler and duplicated summaries before compressing into fragments. Avoid arbitrary sentence-length caps, invented labels, stock praise, and ritual introductions or sign-offs.
  • Replace "world-class expert," "CRITICAL!!!," "be exhaustive," and "never stop" with relevant expertise, observable quality criteria, scope, and a completion condition. A role is useful when it establishes a perspective or responsibility; it does not grant ownership or authority.

For tone-sensitive prompts or a demonstrated writing problem, read references/communication.md. It includes adaptable clauses and before/after examples; don't append it wholesale to every prompt.

Agent prompts

When the prompt drives tools or ongoing work, read references/agent-workflows.md. Define what completion means, what can proceed independently, actual approval boundaries, and what makes a blocker real. Match updates to interactive or unattended use. Specify delegation and verification only to the extent the task needs them; avoid unlimited retry or review loops.

Model-specific tuning

Load the exact version's reference when available; do not substitute an older family guide for a newer version. If no model is specified, use the shared rules without assuming the newest model. These references are dated guidance, not capability guarantees. Check official documentation when configuring APIs or when the version is not covered. Prefer the version-specific guidance over a conflicting shared or legacy pattern.

TargetReference
GPT-6 family; Astra behavior and version-specific API caveatsreferences/gpt-6-astra.md
Claude Opus 5.5references/claude-opus-5.5.md
Claude Fable 5.2 / Mythos 5.2references/claude-fable-5.2.md
Shared Claude patterns; read only for the needed techniquereferences/claude-best-practices.md
Claude Opus 5 (older version)references/claude-opus-5.md
Claude Sonnet 5references/claude-sonnet-5.md
Claude Fable 5 / Mythos 5 (older versions)references/claude-fable-5.md
GPT-5.6 prompting patternsreferences/gpt-5.6.md
GPT-5.6 model/API changesreferences/gpt-5.6-model-guide.md
GPT-5.5references/gpt-5.5.md
GPT-5.4references/gpt-5.4.md

Add model-specific mitigations for a relevant behavior, not as a universal bundle. Effort and visible response length are separate controls. Test advice transferred between versions rather than assuming it still helps.

Output contract

Use the user's requested format and preserve downstream schemas or parser requirements. Otherwise, use compact XML-style sections as the house style for standalone prompts that benefit from sections. Preserve useful existing formatting; a short, self-contained prompt can remain prose when tags add no clarity. XML is a formatting choice, not a quality guarantee.

Use this order as a starting point, keeping only the blocks that contribute useful information:

<objective>
The concrete assignment and intended result.
</objective>

<context>
Relevant background, audience, or established decisions.
</context>

<requirements>
Hard requirements and distinct, checkable acceptance criteria.
</requirements>

<output_format>
The required response format, language, tone, and level of detail.
</output_format>

Combine the assignment and result in <objective> rather than repeating them in a separate <task>. Keep each requirement in one place: combine overlapping constraints, success criteria, and quality checks in <requirements>. Add a separate task or acceptance section only when it carries genuinely distinct content. Do not add empty blocks or expand a clear request just to fill the template.

Use <input> for material to transform or <sources> with identified source blocks for evidence. Keep source content separate from background and instructions. Add role, source-use, tool, or example sections only when the task needs them. Put a brief ambiguity rule in requirements and a requested explanation in the response requirements rather than automatically adding separate policy sections.

For long source-heavy inputs, consider placing the specific objective after the sources while keeping stable application instructions in their proper message layer. Tags do not create instruction priority. These sections form an XML fragment; use a root element and proper serialization if a parser requires a standalone XML document.

Distinguish the format of the prompt you deliver from the format it asks the target model to return. An XML-style prompt can require a JSON response or ordinary prose. Preserve any response schema exactly when it is an integration contract.

For chat delivery, put a standalone prompt in one code block unless the user requests another presentation. If only the final prompt is requested, omit commentary. Otherwise, briefly explain material changes. For repository edits, edit the requested files and report the changes rather than printing the whole skill as a prompt.

Honor the destination's actual limit or an explicit user limit. Otherwise, use the shortest prompt that retains the needed context and requirements; there is no universal character target. A critique does not need a replacement prompt.

Before returning, check

  • Meaning, scope, authorization, and required output contracts preserved.
  • Each added instruction addresses a concrete need; no duplicated or conflicting rules.
  • Evidence, ambiguity, and completion behavior defined where relevant.
  • Format and length fit the user's destination; ready to use.
  • Relevant model/version guidance applied without importing unrelated or conflicting legacy rules.
  • Separate editorial review from measured improvement: if testing is available and warranted, compare old and new prompts on representative cases with the same model and settings. Check task success, factual support, scope, schema compliance, readability, and cost/latency where available. Report what was actually tested; never promise the "best possible" output from wording alone.

Avoid

Generic advice; unnecessary personas or scaffolding; hidden-reasoning requirements; invented capabilities; unsupported performance claims; source material mixed into instructions; examples that silently redefine the task.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.