Skip to content
Skillpedia
Agents280k · #7

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

https://github.com/affaan-m/ECC/blob/main/pi/core/skills/agent-self-evaluation/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/pi/core/skills/agent-self-evaluation/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
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-evaluation

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/agent-self-evaluation/SKILL.md -o SKILL.md
Technical 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:

  1. Read the axis question
  2. Find evidence (or lack of evidence) in the output
  3. Assign a score 1-5
  4. 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:

  1. State what you would do differently
  2. If the gap is fixable in < 30 seconds (missing link, unclear phrasing), fix it now
  3. 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

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills