reverse-prompt

Generate clarifying questions to surface hidden assumptions before coding.

1|Updated Apr 10, 2026

Search Tags:#refactoring #implementation #prompt-engineering #requirements-gathering #clarifying-questions #reverse-prompt

Ready to run

npx skills add https://github.com/ezjonline/ezj-automations --skill reverse-prompt-ezjonline

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: reverse-prompt
Source: https://github.com/ezjonline/ezj-automations/tree/main/skills/reverse-prompt
Command: npx skills add https://github.com/ezjonline/ezj-automations --skill reverse-prompt-ezjonline

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents rushed implementation by surfacing hidden assumptions, edge cases, and preference-driven decisions before any code is written.

Core Features & Use Cases

Generates 5 or more high-impact clarifying questions before non-trivial builds, refactors, or new skill creation.
Focuses on edge cases, integration points, scope boundaries, failure behavior, and implementation tradeoffs.
Helps turn vague requests into precise constraints so the final build matches user intent more reliably.

Quick Start

Ask me to build or refactor something non-trivial and I will first ask the clarifying questions needed to lock down the implementation.

Frequently Asked Questions about reverse-prompt

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I gather implementation requirements before refactoring code?▼

To gather implementation requirements before refactoring, you need to surface hidden assumptions and edge cases by asking high-impact clarifying questions. This approach postpones actual coding until preference-driven decisions and scope boundaries are fully resolved.

What is reverse prompting in software engineering?▼

Reverse prompting in software engineering is a requirements-gathering technique where the assistant asks five or more clarifying questions before non-trivial builds. It forces the resolution of implementation tradeoffs and integration points to prevent rushed coding.

How do I clarify vague feature requests for a new build?▼

You clarify vague feature requests by generating targeted clarifying questions focused on edge cases, failure behavior, and integration points. This turns ambiguous instructions into precise constraints so the final implementation matches the original intent.

When should I use clarifying questions before writing code?▼

You should use clarifying questions before writing code whenever multiple valid implementation paths exist for non-trivial builds, refactors, or script requests. This prevents rushed implementation and ensures final constraints match user intent reliably.

Does this requirements-gathering approach work for simple script requests?▼

This requirements-gathering approach is designed for non-trivial builds and refactors where multiple valid implementation paths exist. Simple script requests with a single obvious solution typically do not require postponing implementation for clarifying questions.

Why does my refactoring implementation miss hidden edge cases?▼

Your refactoring implementation misses hidden edge cases because hidden assumptions and preference-driven decisions were not surfaced before coding. Generating clarifying questions about scope boundaries and failure behavior prevents these missed edge cases.