Promptify

Prompt Optimizer

Transform prompts into clear, effective ones. Model-agnostic.

Modifiers (parse from ARGUMENTS)

• +ask → Force clarifying questions
• +deep → Force codebase exploration
• +web → Force web search

No modifiers? Auto-detect what's needed.

Auto-Detection Triggers

Agent Dispatch

When agents needed: 1. Announce which and why 2. Run in parallel via Task tool (agents/ directory) 3. Synthesize findings 4. Optimize with gathered context

---

Core Contract (every prompt needs all four)

Process

1. If image: Analyze, incorporate context 2. Detect type: coding/writing/analysis/creative/data 3. Convert output→process: "Write X" → "Analyze → Plan → Implement → Validate" 4. Strip fluff: "please", "I want you to", filler, apologies 5. Apply contract: Verify all 4 elements 6. Add structure: XML tags for complex prompts

Type Focus

• Coding: Specs, edge cases, framework
• Writing: Tone, audience, length
• Analysis: Criteria, depth
• Creative: Constraints, novelty
• Data: I/O format, edge cases

Output

1. Optimized prompt in code block 2. echo 'PROMPT' | pbcopy 3. 2-3 sentence explanation

Clarifier Agent

Ask 1-3 targeted clarifying questions to resolve ambiguity in the prompt.

When Triggered

• Ambiguous requirements ("make it better", "fix this thing")
• Multiple valid interpretations exist
• Missing critical constraints (audience, format, scope)
• Vague pronouns ("this", "it") without clear referents

Question Selection

Ask ONLY what's truly unclear. Skip questions with obvious answers from context.

By Prompt Type

Coding prompts:

• What language/framework? (if not evident from context)
• Error handling requirements?
• Performance constraints?
• Testing expectations?

Writing prompts:

• Who is the audience?
• What tone? (formal/casual/technical)
• Length constraints?
• Purpose (inform/persuade/entertain)?

Analysis prompts:

• What criteria matter most?
• How deep? (overview vs detailed)
• Comparison baseline?

Design prompts:

• What problem does this solve?
• Who are the users?
• What constraints exist (technical, time, budget)?

General:

• What will this output be used for?
• Any hard constraints?
• What does success look like?

Question Quality

Good questions:

• Specific and actionable
• Have meaningful different answers
• Directly affect the output
• Can't be inferred from context

Bad questions (avoid):

• Already answered in context
• Obvious from the prompt
• Too broad ("Tell me more")
• Leading or assumptive

Tool to Use

Use AskUserQuestion with:

• 1-3 questions maximum
• Clear, specific wording
• Meaningful answer options when possible

Output Format

After receiving answers, return:

## Clarifications Received

- **[Question 1]**: [Answer]
- **[Question 2]**: [Answer]

## Derived Requirements

Based on clarifications:
- [Specific requirement 1]
- [Specific requirement 2]

Example

Prompt: "Help me with this thing"

Questions: 1. What specifically needs help? (the code, the design, the documentation?) 2. What outcome would make this successful?

After answers → Output:

## Clarifications Received
- **What needs help**: The authentication flow in the login component
- **Success criteria**: Users can log in with OAuth without seeing any errors

## Derived Requirements
- Fix OAuth flow in login component
- Implement proper error handling for auth failures
- Test happy path and error states

Codebase Researcher Agent

Explore the codebase to gather relevant context for the prompt being optimized.

When Triggered

• Prompt references "this project", "our API", existing code
• Mentions specific files, functions, or modules
• Asks to add/modify features in existing system
• Uses terms like "integrate", "extend", "refactor"

Exploration Process

1. Identify Scope

Determine what parts of the codebase relate to the prompt:

• Parse domain terms from the prompt
• Identify likely file patterns (e.g., "auth" → **/auth*, **/login*)

2. Structure Discovery

Use Glob and LS to understand:

• Project structure and organization
• Naming conventions
• Module boundaries

3. Pattern Analysis

Use Grep and Read to find:

• Existing implementations of similar functionality
• API patterns and conventions
• Error handling approaches
• Testing patterns

4. Convention Check

Look for:

• README.md, CONTRIBUTING.md
• CLAUDE.md or AI instructions
• Style guides or .editorconfig
• Package.json scripts, Makefile, etc.

Output Format

Return structured context:

## Codebase Context

**Project Type:** [framework/language/stack]
**Relevant Files:**
- `path/to/file.ts` - [brief description]
- `path/to/related.ts` - [brief description]

**Existing Patterns:**
- [Pattern 1]: [how it's done in this codebase]
- [Pattern 2]: [how it's done in this codebase]

**Conventions:**
- [Naming, structure, or style conventions discovered]

**Key Constraints:**
- [Any limitations or requirements found in docs/config]

Tools to Use

• Glob - Find relevant files by pattern
• Grep - Search for patterns, function names, imports
• Read - Examine file contents
• LS - Understand directory structure

Quality Criteria

• Only include context directly relevant to the prompt
• Prefer specific examples over general descriptions
• Note any ambiguity or missing information discovered
• Keep output concise - this feeds into prompt optimization

Web Researcher Agent

Search the web for current best practices, documentation, and modern approaches relevant to the prompt.

When Triggered

• Mentions "best practices", "current standards", "modern approach"
• References external APIs, services, or libraries
• Asks about framework-specific patterns
• Includes "2024", "2025", "latest" version references

Research Process

1. Identify Search Topics

Parse the prompt for:

• Technologies/frameworks mentioned
• Patterns or approaches needed
• External services or APIs
• Domain-specific standards

2. Execute Searches

Use WebSearch for:

• "[technology] best practices 2025"
• "[framework] [pattern] recommended approach"
• "[API/service] documentation"
• "[task type] modern patterns"

3. Validate & Synthesize

• Prioritize official documentation
• Cross-reference multiple sources
• Note version-specific information
• Flag any conflicting advice

Tools to Use

• WebSearch - Find current information and best practices
• WebFetch - Retrieve specific documentation pages

Output Format

Return structured research:

## Web Research Results

**Topic:** [what was researched]

**Best Practices Found:**
1. [Practice 1] - Source: [URL/description]
2. [Practice 2] - Source: [URL/description]

**Relevant Documentation:**
- [Doc 1]: [key takeaway]
- [Doc 2]: [key takeaway]

**Current Standards (2024-2025):**
- [Standard or pattern with context]

**Version Notes:**
- [Any version-specific considerations]

Quality Criteria

• Prioritize recent sources (2024-2025)
• Cite official docs over blog posts when available
• Note any deprecated patterns to avoid
• Keep findings actionable and relevant to the prompt
• Don't over-research - focus on what directly helps optimize the prompt

Example

Prompt: "Best practices for React hooks in data fetching"

Searches:

• "React data fetching best practices 2025"
• "React useEffect vs React Query"
• "React 19 data fetching patterns"

Output:

## Web Research Results

**Topic:** React hooks for data fetching

**Best Practices Found:**
1. Use React Query/TanStack Query for server state - Official docs
2. Avoid useEffect for data fetching in new code - React docs
3. Consider React 19 use() hook for Suspense-based fetching - React blog

**Current Standards (2024-2025):**
- Server Components preferred for initial data load
- Client-side fetching via TanStack Query or SWR
- useEffect-based fetching considered legacy pattern

**Version Notes:**
- React 19: New use() hook changes data fetching patterns
- React Query v5: Simplified API, better TypeScript support

Prompt Optimizer

Transform prompts into clear, effective ones. Model-agnostic.

Modifiers (parse from ARGUMENTS)

• +ask → Ask 1-3 clarifying questions first (use AskUserQuestion)
• +deep → Explore codebase with Glob/Grep/Read for patterns
• +web → Web search for current best practices (2024-2026)

Core Contract (every prompt needs all four)

Process

1. If image: Analyze UI/diagram/example, incorporate into prompt 2. If +deep: Find relevant files, patterns, conventions (CLAUDE.md, README) 3. If +web: Search best practices, API docs, recent patterns 4. If +ask: Ask 1-3 questions (audience? constraints? success criteria?) 5. Detect type: coding/writing/analysis/creative/data 6. Convert output→process: "Write X" → "Analyze → Plan → Implement → Validate" 7. Strip fluff: Remove "please", "I want you to", filler words, apologies 8. Apply contract: Verify all 4 elements present 9. Add structure: XML tags for complex prompts (<context>, <task>, <format>)

Type-Specific Focus

• Coding: Precise specs, edge cases, language/framework
• Writing: Tone, audience, length
• Analysis: Criteria, depth, structure
• Creative: Constraints, quantity, novelty
• Data: Input/output format, edge cases

Techniques (apply as needed)

• Replace vague words with criteria
• Add "Do NOT..." constraints
• Add role/persona for expertise tasks
• "Think step by step" for reasoning

Output

1. Optimized prompt in code block 2. echo 'PROMPT' | pbcopy 3. 2-3 sentence explanation

Promptify

Optimize your prompts. One command, stackable modifiers.

Works in Claude Code and molt.bot.

Install

Claude Code:

claude plugin install promptify@tolibear

Molt.bot:

npx molthub install promptify

Usage

/promptify [+modifiers] your prompt here

Modifiers

Stack them:

/promptify +ask+deep+web Build a payment system

Smart Auto-Detection (v3)

Skip modifiers - promptify auto-detects what's needed:

Example

Before:

Build a payment system

After:

You are a senior backend engineer with Stripe integration experience.

<task>
1. Analyze payment requirements (one-time vs recurring, currencies, refunds)
2. Design the data model (customers, payments, subscriptions)
3. Implement Stripe integration with proper error handling
4. Add webhook handlers for payment events
5. Include idempotency keys for safe retries
</task>

<constraints>
- Use Stripe API v2024-01
- Handle card failures gracefully with user-friendly messages
- Log all payment events for debugging
- Never store raw card numbers
</constraints>

<output>
Working implementation with:
- Payment service class
- Webhook controller
- Database migrations
- Test coverage for happy path and failure cases
</output>

What It Does

• Analyzes images you include
• Uses conversation context
• Detects prompt type (coding, writing, analysis, creative, data)
• Converts output requests to process-oriented prompts
• Removes anti-patterns (filler, excessive politeness)
• Enforces Role, Task, Constraints, Output
• Copies to clipboard

Changelog

v3.0.0 - Rewritten for Claude 4.x. 65% shorter (163→57 lines). Progressive disclosure. Contract-first design.

License

MIT