dotneet Prompt Improver
Overview
A skill that analyzes and improves prompts based on general LLM/agent best practices. It focuses on verifiability, clear scope, explicit constraints, and context economy so the agent can execute with minimal back-and-forth.
If you are running in Claude Code, also read references/claude.md and apply the additional Claude-specific techniques.
If you are running in Codex CLI, also read references/codex.md and apply the additional Codex-specific techniques.
When the input is a document that instructs an agent (e.g., plan files, AGENTS.md, system instruction docs), treat the document as the improvement target; identify issues and propose concrete improvements, and include a revised draft when helpful.
Workflow
Step 0: Classify Task and Complexity
Classify the task and decide whether an explicit exploration/planning phase should be recommended:
- Task type: bugfix, feature, refactor, research, UI/visual, docs, ops
- Complexity: single-file/small change vs multi-file/uncertain impact
- Risk: data safety, security, compatibility, performance
- Input type: prompt vs agent-instruction document (plan files, AGENTS.md, system instruction docs)
If the task is complex or ambiguous, the improved prompt should explicitly request an exploration/planning phase before implementation.
Step 1: Analyze the Prompt
Analyze the user-provided prompt from the following perspectives:
- Verifiability: Does it include means for Claude to verify its own work?
- Specificity: Are files, scenarios, and constraints clearly specified?
- Context: Is necessary background information provided?
- Scope: Is the task scope appropriately defined?
- Expected Outcome: Are success criteria clear?
- Constraints: Are language/runtime versions, dependencies, security, or compatibility requirements specified?
- Context Economy: Is the prompt concise and focused, without unnecessary information?
- Execution Preference: Is it clear whether the model should implement, propose, or just analyze?
Step 2: Identify Issues
Check for the following anti-patterns:
| Anti-pattern | Description |
|---|---|
| Vague instructions | Lacks specificity like "make it better" or "improve it" |
| No verification method | Missing tests, screenshots, or expected output |
| No verification commands | Missing how to run tests or check outputs |
| Overly broad scope | Asking for too many things at once |
| Insufficient context | Missing file paths, error messages, or references to existing patterns |
| Symptom-only description | Not requesting investigation of root cause |
| Missing constraints | No environment, dependency, or compatibility requirements |
| No exploration/planning cue | Complex tasks not asking for exploration/planning first |
| Context bloat | Unnecessary details that increase token usage |
| Ambiguous deliverable | Unclear whether to plan, implement, or only analyze |
| Unclear response format | Missing brevity/structure expectations |
Step 3: Create Improved Prompt
Apply best practices to create an improved version:
Add Verifiability
Before: "implement a function that validates email addresses"
After: "write a validateEmail function. test cases: user@example.com is true, invalid is false, user@.com is false. run the tests after implementing"
Add Specific Context
Before: "fix the login bug"
After: "users report that login fails after session timeout. check the auth flow in src/auth/, especially token refresh. write a failing test that reproduces the issue, then fix it"
Add Reference to Existing Patterns
Before: "add a calendar widget"
After: "look at how existing widgets are implemented on the home page to understand the patterns. HotDogWidget.php is a good example. follow the pattern to implement a new calendar widget with month selection and pagination"
Add Context Economy
Before: "here is a long unrelated history ... fix the dropdown"
After: "fix the dropdown in src/ui/Dropdown.tsx. issue: keyboard navigation skips items. keep the prompt focused; omit unrelated history"
Add Rich Context Inputs
Before: "build fails"
After: "build fails with this error: [paste error]. run the smallest relevant test command. if needed, read the build script and package config"
Add Explicit Exploration/Planning When Needed
Before: "refactor auth to support OAuth"
After: "first explore src/auth and summarize current flow, then propose a plan. after approval, implement with tests"
When information is missing, include explicit questions inside the improved prompt and do not assume defaults.
Example: Bugfix
Before: "search is broken"
After: "users report search returns empty results for queries with hyphens. reproduce in src/search/. paste the error log if any. write a failing test for 'foo-bar' returning results, fix the root cause, run: pnpm test --filter search"
Example: UI/Visual
Before: "make the dashboard look better"
After: "implement the attached screenshot for the dashboard header in src/ui/DashboardHeader.tsx. match spacing and typography. take a new screenshot and list any differences. run: pnpm lint"
Example: Refactor
Before: "clean up the auth code"
After: "inspect src/auth and list duplication hotspots. propose a refactor plan scoped to one module. after approval, remove duplication without changing behavior. add a targeted test if coverage is missing. run the smallest relevant test command"
Example: Research
Before: "why is this API slow?"
After: "explore request flow around src/api/. summarize likely bottlenecks with evidence (logs, timings). propose 2-3 hypotheses and what data is needed to confirm. do not implement yet. if needed, ask for access to profiling output"
Example: Ops
Before: "deployment failed"
After: "deploy fails with error: [paste log]. identify the failing step in scripts/deploy.sh and related CI config. suggest a fix and a rollback plan. run: ./scripts/deploy.sh --dry-run (if available)"
Example: Docs
Before: "update the README"
After: "update README.md to include install + dev steps based on existing scripts. keep it concise. confirm commands exist and match actual scripts"
Step 4: Output Format
Output in the following format:
## Prompt Analysis
### Original Prompt
[User-provided prompt]
### Issues
- [Issue 1 and its impact]
- [Issue 2 and its impact]
...
### Missing Information (Questions to Ask)
The following questions should be answered to make the prompt more effective:
- [Question 1] (Why it is needed)
- [Question 2] (Why it is needed)
...
### Verification Plan
- Commands to run (tests, build, lint, screenshots)
- Expected results or acceptance criteria
### Exploration/Planning Recommendation
- Recommend exploration/planning first? [Yes/No] and why
### Execution Preference
- Implement now / propose plan only / analyze only
- Any constraints on response length or format
### Improved Prompt
[The improved prompt]
### Document Improvement Suggestions (if applicable)
- [Issue and concrete improvement for the instruction document]
- [Issue and concrete improvement for the instruction document]
### Revised Document (optional)
[A revised draft of the instruction document when helpful]
### Improved Prompt Template (optional)
Use this as a fill-in template if the user wants a reusable prompt format:
[Task]
- Goal:
- Target files/paths (@...):
- Constraints (runtime/version/deps/security/compat):
- Context (symptom, logs, repro, links):
[Verification]
- Commands:
- Expected results:
- UI checks (screenshots/visual diffs):
[Exploration/Planning]
- Do exploration/planning first? (Yes/No) + reason:
[Execution Preference]
- Implement now / plan only / analyze only
- Output format (concise report, patch summary, checklist, etc.)
### Short Prompt Template (optional)
Use this when the user wants the shortest effective prompt:
Goal: ... Targets: path1/path2 Context: symptom + repro + logs Constraints: runtime/deps/compat Verify: command + expected result Explore/Plan: yes/no (why) Execute: implement / plan only / analyze only Output: concise format
### Improvement Points
1. [Explanation of improvement 1]
2. [Explanation of improvement 2]
...
### Additional Recommendations (optional)
- [Whether to do exploration/planning first]
- [Whether to parallelize or delegate investigation]
- [Whether preliminary research is needed]
- [Ways to reduce context usage]
Reference: Best Practices Checklist
Best practices to reference when improving prompts:
Provide Verification Methods
- Include test cases
- Specify expected output
- For UI changes, request screenshot comparison
- Add "run the tests" or "verify the build succeeds"
- Include explicit commands to run
Explore → Plan → Implement Order
- Use an exploration/planning phase first for complex tasks
- Create a plan before implementation
- Small fixes don't need a formal plan
- When uncertain, ask clarifying questions before coding
Include Specific Context
- Paste error messages
- Specify existing patterns
- Clarify edge cases
- State environment constraints (runtime, language versions, dependencies)
Use Rich Inputs
- Paste logs and stack traces
- Provide URLs for docs or API references
- Attach or paste large text outputs when needed
Manage Context Window
- Keep prompts concise and focused
- Remove unrelated history or speculation
- Ask for missing info instead of guessing
Leverage Parallelism/Delegation
- For research tasks: request parallel investigation or summaries
- For code review: request an independent review pass
- Keeps the main task focused
Patterns to Avoid
- Vague instructions like "make it better" or "improve it"
- Implementation requests without verification methods
- Multiple unrelated tasks at once
- Requesting changes to files not yet read
- Large context dumps with no clear signal