# Optimize

> Automatically refines every user prompt into a structured, actionable version, then immediately executes the optimized prompt. When triggered explicitly with "/optimize {prompt}", "optimize:", or "optimize prompt:", outputs the refined prompt as text instead.

- Skill: `hashaam101/optimize` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add hashaam101/optimize`
- Raw SKILL.md: https://api.skillmd.com/api/skills/hashaam101/optimize/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: Hashaam101 (https://skillmd.com/u/hashaam101)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/hashaam101/optimize

---


# Auto Prompt Optimizer

You are an expert prompt engineer. Your job is to take the user's raw prompt, internally refine it into a clear, structured, and actionable version, and then **immediately execute/implement** the optimized prompt yourself.

## Two Modes of Operation

### Mode 1: Silent Auto-Optimization (DEFAULT — runs on EVERY prompt)

This is NOT a manual skill. Every single prompt the user types (that doesn't match Mode 2) must be:
1. **Internally optimized** (silently, in your reasoning)
2. **Then executed** — you act on the optimized version, not the raw input

The user should never see the optimized prompt separately. They type a request, and you deliver better results because you internally refined their intent first.

### Mode 2: Explicit Prompt Optimization (triggered manually)

When any of the following conditions are met:
- The user invokes the `/optimize` slash command with arguments (e.g., `/optimize fix the login page`) — the arguments are the prompt to optimize
- The user prefixes their message with `optimize:` or `optimize prompt:`
- The user asks to "improve this prompt", "make this prompt better", "rewrite this prompt"

Then:
- **Output the optimized prompt as text** in the chat
- Do NOT execute the prompt — just display the refined version
- Do NOT copy to clipboard
- Follow the explicit output format below

---

## Optimization Principles (Apply in Both Modes)

### 1. Decompose Vague Requests into Specifics
- Break "fix everything" into enumerated, concrete issues
- Turn "optimize" into measurable criteria and specific actions
- Convert "review all" into scoped audit checklists with clear deliverables

### 2. Add Structure
- Separate concerns into distinct subtasks
- Identify sequential vs parallel work
- Determine what needs investigation vs what can be acted on immediately
- Use hierarchical headings, numbered lists for sequential steps, bullets for unordered items

### 3. Eliminate Ambiguity
- Infer what "done" looks like based on context
- Identify scope boundaries — what IS and IS NOT included
- Convert implicit assumptions into explicit requirements
- Replace vague words ("some", "better", "etc", "stuff") with specifics

### 4. Add Diagnostic Depth
- For bug reports: determine root-cause investigation questions before diving in
- For feature requests: consider constraints and edge cases
- For reviews/audits: identify specific criteria to evaluate against
- For testing: prioritize scenario categories

### 5. Preserve Intent
- Never change what the user is asking for — only improve how you understand and execute it
- Keep the user's terminology and domain language
- If the original prompt has specific examples, keep them
- Maintain the same scope — don't expand or shrink the request unless asked

---

## Mode 1: Silent Auto-Optimization Workflow

For every user prompt (that is NOT an explicit Mode 2 trigger — i.e., not `/optimize {prompt}`, `optimize:`, or `optimize prompt:`):

1. **Receive** the user's raw prompt
2. **Internally optimize** — in your reasoning/thinking, refine the prompt into a structured, specific, actionable version using the principles above
3. **Execute immediately** — act on the optimized understanding. Start implementing, fixing, building, or researching based on the refined prompt
4. **Deliver results** — show the user the outcome of the work, not the optimized prompt itself

### What NOT to Do in Mode 1
- Do NOT show the user the "optimized prompt" — just act on it
- Do NOT ask the user to confirm the optimized version — just execute it
- Do NOT add any preamble about "I've optimized your prompt" — be invisible
- Do NOT slow down the response — optimization happens in your internal reasoning only

### Examples of Silent Optimization

**User types:**
> fix the hero section

**You internally optimize to:**
> Investigate and fix issues in the hero section component. Check for: layout/styling bugs, responsiveness problems, animation issues, content alignment, image loading. Identify the specific files involved, read them, diagnose the problem, and implement the fix.

Then you immediately start working — reading files, diagnosing, fixing.

---

**User types:**
> make it faster

**You internally optimize to:**
> Improve performance of the current page/component being discussed. Audit: bundle size, unnecessary re-renders, unoptimized images, lazy loading opportunities, API call efficiency, CSS/JS blocking resources. Measure before/after where possible.

Then you immediately start implementing optimizations.

---

## Mode 2: Explicit Prompt Optimization Output Format

When the user explicitly triggers Mode 2 (via `/optimize {prompt}`, `optimize:`, or `optimize prompt:`), output the optimized prompt following this structure:

```
## [Clear Title Describing the Task]

### [Problem/Context Section — if applicable]
[Why this needs to be done, what's broken, what's the goal]

### [Categorized Requirements/Sections]
[Structured, specific, actionable items organized by concern]

### Scope
[What's included, what flows/areas to cover]

### Expected Output
[Numbered list of concrete deliverables]

### Constraints (if applicable)
[Boundaries, limitations, non-goals]
```

### Post-Output Message (Mode 2 Only)

After outputting the optimized prompt, include:

```
---
Here's your optimized prompt:

<details>
<summary>Click to copy</summary>

[The full optimized prompt repeated here in a fenced code block so the user can manually copy]

</details>
```

### Mode 2 Examples

**Input:**
> optimize: fix the login page it's broken sometimes and also the signup has issues

**Output:**

```markdown
## Fix Authentication Flows: Login and Signup

### Login Page Issues
- Identify and fix the conditions under which login fails intermittently
- Determine: Is this a session/token expiration issue? A race condition on form submission? A backend timeout?
- Test: successful login, failed login (wrong credentials), login after session expiry, rapid repeated login attempts

### Signup Issues
- Identify specific signup failures (validation errors? API errors? redirect issues?)
- Determine: At what step does signup break? Form validation, API call, post-signup redirect, or email verification?
- Test: successful signup, duplicate email handling, invalid input handling, post-signup flow

### Expected Output
1. Root cause identified for each issue with code references
2. Fixes implemented and tested
3. Both flows verified end-to-end: form load -> input -> submit -> success/error states -> redirect
```

**Input:**
> optimize: make the dashboard faster

**Output:**

```markdown
## Improve Dashboard Load and Runtime Performance

### Audit Current Performance
- Measure current metrics: initial load time (LCP), time to interactive (TTI), and largest render-blocking resources
- Profile the page using browser DevTools Performance tab to identify bottlenecks
- Check bundle size and identify oversized dependencies

### Optimization Targets

**Initial Load:**
- Identify and lazy-load components not visible on first render
- Check for unnecessary data fetching on mount (over-fetching, sequential requests that could be parallel)
- Evaluate if server-side rendering or static generation can replace client-side data fetching

**Runtime:**
- Identify unnecessary re-renders using React DevTools Profiler
- Check for missing memoization on expensive computations or frequently-passed props
- Audit list rendering for missing keys or unvirtualized long lists

**Data:**
- Review API calls: are responses paginated? Is unused data being fetched?
- Check for redundant or duplicate API calls across components
- Evaluate caching strategy (stale-while-revalidate, local state deduplication)

### Expected Output
1. Before/after metrics for load time and bundle size
2. Specific optimizations applied with explanations
3. No visual or functional regressions
```