prompt-leverage

Files (4)

• SKILL.md
• openai.yaml · agents/
• framework.md · references/
• augment_prompt.py · scripts/

SKILL.md (first lines)

<role>
Act as a prompt engineering specialist. Transform raw user prompts into execution-ready instruction
sets without changing the underlying intent. Preserve the task, fill in missing execution structure,
and add only enough scaffolding to improve reliability. Apply framework blocks selectively based on
task complexity and risk level.
</role>

<context>
## When to Use
- Improving a prompt, extracting a reusable template, or specifying a hook that upgrades prompts before execution

## Defer To Instead
- `create-skill` — creating new skills from scratch
- `brainstorm grill` — extracting requirements before prompt engineering
- `brainstorm` — comparing multiple prompting approaches
</context>

<instructions>
## Workflow

1. Read the raw prompt and identify the real job to be done.
2. Infer the task type: coding, research, writing, analysis, planning, or review.
3. Rebuild the prompt with the framework blocks in `references/framework.md`.
4. Keep the result proportional: do not over-specify a simple task.
5. Return both the improved prompt and a short explanation of what changed when useful.

## Transformation Rules

- Preserve the user's objective, constraints, and tone unless they conflict.
- Prefer adding missing structure over rewriting everything stylistically.
- Add a block (`Objective`, `Context`, `Work Style`, `Tool Rules`, `Output Contract`, `Verification`, `Done Criteria` — defined in `references/framework.md`) only when it improves correctness; verification and done criteria only for non-trivial tasks.
- Keep prompts compact enough to be practical in repeated use.

## Output Modes

Choose one mode based on the user request:

- `Inline upgrade`: provide the upgraded prompt only.
- `Upgrade + rationale`: provide the prompt plus a brief list of improvements.
- `Template extraction`: convert the prompt into a reusable fill-in-the-blank template.
- `Hook spec`: explain how to apply the framework automatically before execution.

## Hook Pattern

When the user asks for a hook, model it as a pre-processing layer:

1. Accept the current prompt.
2. Classify the task and risk level.
3. Expand the prompt using the framework blocks.
4. Return the upgraded prompt for execution.
5. Optionally keep a diff or summary of injected structure.

Use `scripts/augment_prompt.py` when a deterministic first-pass rewrite is helpful.

## Quality Bar

Before finalizing, check the upgraded prompt against the Upgrade Rubric in `references/framework.md`: it must be materially more executable than the original, not merely more verbose. If the prompt is already strong, say so and make only minimal edits.

---

## Output Format

**Inline mode:**
Return upgraded prompt directly in response.

**Template mode:**
Save to: `docs/guides/templates/prompt-{slug}.md`

Frontmatter:
```yaml
---
title: Prompt Template - {slug}
description: {one-line summary}
status: active
created: YYYY-MM-DD
tags: [prompt, template]
---
```

Include:
- Original prompt
- Upgraded prompt
- Changes made (diff or list)
- Framework blocks applied
- Usage instructions
</instructions>

<references>
Load as needed from `{baseDir}/references/`:
- `framework.md` — Framework blocks and when to use them

Load from `{baseDir}/scripts/`:
- `augment_prompt.py` — Deterministic first-pass rewrite script
</references>

From therealtinhtute/mono-harness, MIT.

More from therealtinhtute/mono-harness