evaluator-optimizer
Iterative refinement workflow for polishing code, documentation, or designs through systematic evaluation and improvement cycles. Use when refining drafts into production-grade quality.
Best use case
evaluator-optimizer is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Iterative refinement workflow for polishing code, documentation, or designs through systematic evaluation and improvement cycles. Use when refining drafts into production-grade quality.
Teams using evaluator-optimizer should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/evaluator-optimizer/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How evaluator-optimizer Compares
| Feature / Agent | evaluator-optimizer | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Iterative refinement workflow for polishing code, documentation, or designs through systematic evaluation and improvement cycles. Use when refining drafts into production-grade quality.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
# Evaluator-Optimizer Iterative refinement workflow that takes existing code, documentation, or designs and polishes them through rigorous cycles of evaluation and improvement until they meet production-grade quality standards. ## When to Use This Skill - Refining a rough draft of code into production quality - Polishing documentation for clarity, completeness, and accuracy - Iteratively improving a design or architecture proposal - Systematic quality improvement where "good enough" is not sufficient - When you need to converge on high quality through structured iteration ## Quick Reference | Task | Load reference | | --- | --- | | Evaluation criteria and quality rubrics | `skills/evaluator-optimizer/references/evaluation-criteria.md` | ## Workflow: The Loop For any given artifact (code, text, design): 1. **Accept**: Take the current version of the artifact. 2. **Evaluate**: Act as a harsh critic. Rate the artifact on correctness, clarity, efficiency, style, and safety. Assign a score out of 100. 3. **Decide**: - Score >= 90: **Stop** and present the result. - Score < 90: **Refine**. 4. **Refine**: Rewrite the artifact, specifically addressing the critique from step 2. List what changed and why. 5. **Repeat**: Return to step 2 with the new version. ## Behavioral Rules - **Do not settle**: "Good enough" is not good enough. You are here to polish. - **Be explicit**: When evaluating, list specific flaws. "The function `process_data` is O(n^2) but could be O(n)." - **Show your work**: Summarize changes in each iteration. - **Self-correct**: If a refinement breaks something, revert and try a different approach. - **Converge**: Each iteration must improve the score. If two consecutive iterations do not improve the score, stop and present the best version. ## Iteration Output Template ```markdown ## Iteration [N] Evaluation | Criterion | Score (1-10) | Notes | |-----------|-------------|-------| | Correctness | | | | Clarity | | | | Efficiency | | | | Style | | | | Safety | | | | **Total** | **/50** | **[x100/50]** | ### Issues Found 1. [Specific issue with location] 2. [Specific issue with location] ### Refinements Applied - [Change 1 and rationale] - [Change 2 and rationale] ``` ## Example Interaction **Input**: "Refine this Python script." **Iteration 1 Evaluation**: - Functionality: Good - Efficiency: Poor - uses nested loops for matching - Style: Variable names `a` and `b` are unclear - Score: 60/100 **Refinements applied**: - Flattened loops using a set lookup (O(n)) - Renamed `a` to `users`, `b` to `active_ids` - Added type hints **Iteration 2 Evaluation**: - Functionality: Good - Efficiency: Excellent - Style: Good - Score: 95/100 Result: Present the refined script.
Related Skills
writing-skills
Use when creating new skills, editing existing skills, or verifying skills work before deployment - applies TDD to process documentation by testing with subagents before writing, iterating until bulletproof against rationalization
workflow-security-audit
Comprehensive security assessment and remediation. Use for security reviews, compliance checks, vulnerability assessments.
workflow-performance
Systematic performance analysis and optimization. Use when things are slow, need optimization, or preparing for scale.
workflow-feature
Complete feature development workflow from design to deployment. Use when implementing new features or functionality.
workflow-feature-development
Complete workflow for developing new features from design to deployment. Use when starting a new feature, adding functionality, or building something new.
workflow-bug-fix
Systematic approach to identifying, fixing, and validating bug fixes. Use when fixing bugs, resolving issues, or addressing errors.
wiring-audit
User-triggered audit that finds wiring drift between a project's UI surfaces and backend capabilities — orphan surfaces (UI calls endpoints/hooks/procedures that no longer exist), unwired capabilities (backend routes/exports that nothing surfaces), shape drift (both exist but contracts mismatch), method drift (URL matches, HTTP verb does not), validation drift (frontend vs backend rules diverged), permission drift (UI exposes what backend forbids or vice versa), stale labels (UI text references renamed backend concepts), and unsurfaced configuration (env vars or flags that gate behavior with no UI or CLI to control them). This skill should be used when the user asks to "audit our wiring," "find UI/backend drift," "find unwired capabilities," "find stale surfaces," "check for contract violations," "find unused endpoints," "find unused hooks," "what mismatches between UI and backend," or any similar request whose deliverable is a prioritized findings report rather than a descriptive snapshot. Generic across UI frameworks but optimized for React applications (hooks, fetch, react-query, SWR, tRPC, server actions, react-router, Next.js). Not for descriptive architectural snapshots (use architectural-analysis), security audits (use security-auditor), or performance audits (use workflow-performance).
webapp-testing
Toolkit for interacting with and testing local web applications using Playwright. Use when verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
web-researcher
Use this skill when you need to research a topic online, gather information from multiple sources, or evaluate source credibility. Trigger phrases: 'research', 'find information about', 'look up', 'investigate'. Not for academic systematic reviews (use literature-reviewer) or fact-checking specific claims (use fact-checker).
visual-modes
Use when activating visual showcase modes (supersaiyan, kamehameha, over9000) for UI or interaction design - provides mode-specific enhancement checklists.
vibe-security
Comprehensive secure coding guide covering OWASP web vulnerabilities with prevention patterns and checklists. Use when writing or reviewing web application code to prevent XSS, CSRF, SSRF, SQL injection, access control flaws, and other common security vulnerabilities.
verification-before-completion
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always