agent-self-evaluation
Helps your agent evaluate its own work. It checks if the answers are correct, complete, and clear, suggesting improvements for the future.
What it does
This tool helps the AI check if the work it just did is good. It rates itself on 5 aspects: accuracy, completeness, clarity, actionability, and conciseness, giving scores and suggestions for improvement.
When to use it
- ✓After completing a complex task.
- ✓When the AI needs to ensure it did everything correctly.
- ✓If you ask 'how good was that?'
Example of what to ask your AI
“Evaluate the code you just wrote.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The AI compares what it did with your request, looking at 5 criteria. For any score below 5, it explains exactly what was missing or wrong.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add affaan-m/ECC --skill agent-self-evaluationOr download just the file:
curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/agent-self-evaluation/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Agent Self-Evaluation
After completing a complex task, the agent pauses to rate its own output against a structured 5-axis rubric. This is NOT a pass/fail gate — it's a deliberate reflection step that catches omissions, flags overconfidence, and surface areas for improvement before the user has to.
When to Activate
- After writing code that spans 3+ files or 50+ lines
- After completing a multi-step workflow (implement → test → review)
- After a debugging session that involved 3+ attempts
- After producing a design document, architecture decision, or written analysis
- When the user asks "how good was that?" or "rate yourself"
- At the end of any session Stop hook (if configured — see
references/hook-integration.md)
Core Concepts
The 5 Evaluation Axes
| Axis | Question | What it catches |
|---|---|---|
| Accuracy | Are the facts, claims, and outputs correct? | Hallucinations, wrong API names, incorrect syntax, false statements |
| Completeness | Did it cover everything the user asked for? | Missed edge cases, unhandled error paths, forgotten requirements, skipped subtasks |
| Clarity | Is the explanation understandable and well-structured? | Confusing explanations, jargon without definition, missing context, rambling |
| Actionability | Can the user act on the output immediately? | Vague suggestions, missing steps, "you should X" without showing how, no verification path |
| Conciseness | Did it use the minimum words/tokens needed? | Redundancy, over-explanation, repeating the user's question verbatim, filler content |
Scoring Scale
5 — Exceptional: no reasonable improvement possible
4 — Good: minor nits only, no substantive gaps
3 — Adequate: meets the request but has a notable weakness on at least one axis
2 — Weak: has a clear gap that affects usability or correctness
1 — Poor: fundamentally misses the request or contains significant errors
The Evidence Rule
Every score below 5 MUST cite specific evidence. A score of 3 cannot just say "could be better" — it must say exactly what is missing or wrong. The mantra: "Show the gap, don't just name it."
Workflow
Step 1: Collect the Raw Material
Gather what you'll evaluate:
- The original user request (read back from conversation)
- Your final response/output (the deliverable)
- Any tool outputs that verify correctness (test results, exit codes, lint output)
- Any user feedback received during the task (corrections, "try again", "that's not right")
Step 2: Score Each Axis Independently
Work through the 5 axes one at a time. For each:
- Read the axis question
- Find evidence (or lack of evidence) in the output
- Assign a score 1-5
- If score < 5, write a one-sentence improvement note citing the gap
Do NOT average the scores in your head first and then work backwards. Score each axis fresh.
Step 3: Produce the Evaluation Report
Use the template from templates/evaluation-report.md. The report must include:
- One-line summary
- 5-axis scorecard (score + evidence per axis)
- Overall score (simple average, rounded to 1 decimal)
- 1-3 specific improvements ranked by impact
- Self-check: "Would the user agree with this assessment?"
Step 4: Apply the Improvement
If any axis scored 3 or below:
- State what you would do differently
- If the gap is fixable in < 30 seconds (missing link, unclear phrasing), fix it now
- If the gap requires rework, flag it explicitly: "This axis scored [reason] because [evidence]. Re-running with [specific fix] would likely raise it to [score]."
Code Examples
Example: Good Evaluation (Score 4+)
Task: Add retry logic to HTTP client
Scorecard:
Accuracy: 5 — All API calls correct. Verified: retries use
exponential backoff. No hallucinated methods.
Completeness: 4 — Covered happy path + 3 error cases. Missing:
timeout handling for hung connections.
Clarity: 5 — Code comments explain backoff formula.
PR description links to incident that motivated this.
Actionability:5 — Single merge. No follow-up tasks. Tests pass.
Conciseness: 4 — 47 lines total. The retry loop could be extracted
into a helper to drop ~8 lines.
Overall: 4.6 — One gap (timeout handling). Fix before merging.
Example: Weak Evaluation (Score 2-3)
Task: Add retry logic to HTTP client
Scorecard:
Accuracy: 2 — Used urllib3 which doesn't match our
…
FAQ
What are the 5 evaluation axes?
They are the criteria: Accuracy (if it's correct), Completeness (if it covered everything), Clarity (if it's easy to understand), Actionability (if it's immediately usable), and Conciseness (if it's straight to the point).
What does a score of 5 mean?
It means the work is exceptional, with no reasonable room for improvement.
Why does the AI need to self-evaluate?
To ensure the final output is the best it can be, catching errors or weaknesses before you have to point them out.
Details
Original description by the author
Use after completing any non-trivial task. The agent self-rates its output on 5 axes — accuracy, completeness, clarity, actionability, conciseness — with concrete evidence per criterion. Produces a structured 1-5 scorecard with specific improvement suggestions.
repo: affaan-m/ECC
Popularity
- GitHub stars
- 280k
- Ranking position
- #7
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
accessibility
Helps your agent create interfaces that everyone can use. Ensures websites and apps work well for people with disabilities, like those who are blind or have reduced mobility.
affaan-m/ECC
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC
Similar skills
mcp-builder
Helps your agent create servers that connect LLMs to external services. Essential for integrating APIs and services using Python or Node/TypeScript.
anthropics/skills
prepare-mcp-integration
Prepares vendor (MCP) integrations through research and human approval. It follows a guided process for new integrations.
paperclipai/paperclip
first-task
Guides the agent on the user's first task. It interprets the initial answer, clarifies the goal, and proposes a plan or single task for approval.
paperclipai/paperclip