Skip to content
Skills Library
AI & agents · Review & audit

self-reflection

/self-reflection

Have an agent critique and improve its own output before delivering, catching errors a first pass misses, without spiraling. Use when correctness matters and an agent should check its own work rather than ship the first draft.

Repository
AI-SKILLS ↗
Licence
MIT
Last repository change
05.09.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Have an agent critique and improve its own output before delivering, catching errors a first pass misses, without spiraling. Use when correctness matters and an agent should check its own work rather than ship the first draft.

Original author description

Have an agent critique and improve its own output before delivering, catching errors a first pass misses, without spiraling. Use when correctness matters and an agent should check its own work rather than ship the first draft.

How it works

  1. Method
  2. Boundaries
Original SKILL.md headings · 54 lines, 424 words
SKILL.md preview
---
name: self-reflection
description: Have an agent critique and improve its own output before delivering, catching errors a first pass misses, without spiraling. Use when correctness matters and an agent should check its own work rather than ship the first draft.
---

# Self-reflection

An agent's first output is a first draft, and first drafts have errors the
agent can catch if it looks. Self-reflection is the agent reviewing its own
work critically before delivering it: a cheap, high-value step that turns
plausible-but-wrong into checked-and-right. The craft is making the
critique genuine and bounded, not theater or an infinite loop.

## Method

1. **Separate the critic from the author.** Reflection works when the agent
   reviews as a skeptic who did not write the work, actively looking for
   what is wrong, not admiring it. A review that assumes the work is good
   finds nothing. Prompt the critique to assume at least one real problem
   exists and find it (see review-my-code's evidence-first ethic).
2. **Check against the goal and requirements first.** Does the output
   actually do what was asked and meet every stated requirement? Re-read the
   requirements literally; the most common failure is confidently solving a
   slightly different problem than the one posed (see goal-driven-execution's
   done-condition).
3. **Verify claims, do not just re-read them.** For facts and numbers, check
   them against sources rather than trusting the draft (see fact-checking);
   for code, run it or trace it, do not eyeball it (see verify skill); for
   reasoning, test the weak links. Reflection that only re-reads catches
   wording, not errors.
4. **Prioritize findings, worst first.** Separate must-fix (wrong,
   incomplete, unclear on the core) from nice-to-have polish, and address the
   must-fixes. Not every observation deserves a rewrite; the goal is a
   correct, clear result, not an endlessly buffed one.
5. **Bound the reflection.** One or two reflection passes catch most of the
   value; beyond that, returns diminish and the agent can spiral,
   second-guessing correct work or oscillating between versions. Set a cap,
   and if reflection stops finding real problems, stop and deliver (see
   agentic-loops' termination).
6. **Know when reflection cannot self-correct.** An agent blind to its own
   error (a wrong assumption it also uses to check) will not catch it by
   reflecting; genuinely high-stakes work needs an independent check (a
   different model, a tool, a human), not just more self-review (see
   agent-eval-design, llm-guardrails).

## Boundaries

- Self-reflection improves the average output but is not a correctness
  guarantee; an agent can confidently ratify its own mistake. For anything
  where being wrong is costly, pair it with external verification (see
  agent-eval-design, agent-qa-gate).
- Reflection has a cost (tokens, latency); reserve the deeper self-review for
  work where correctness matters, not every trivial response (see
  llm-cost-latency).
- Over-reflection degrades good work (blandness, needless churn) and wastes
  budget; the discipline is bounded, prioritized critique, not infinite
  self-doubt.

Versions

RepositoryScoreLicence
This page · Amey-Thakur/AI-SKILLS90MIT
netanel-abergel/pa-skills90MIT

Database snapshot: 13.11.2026 · package version eb1ec4e85c27 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100self-refine-loop
    Runs a generator-critique-reviser loop to iteratively improve agent outputs. Use for: self refine, reflexion loop, critique and revise, improve output.
  • 100agent-planning-react-reflection-loops
    Use this skill when implementing Thought-Action-Observation loops, Plan-and-Solve strategies, and self-reflection in autonomous agents.
  • 98skill-101
    Patterns and techniques for evaluating and improving AI agent outputs. Use this skill when implementing self-critique and reflection loops, building evaluator-optimizer pipelines for quality-critical generation, creating test-driven code refinement workflows, designing…
  • 100dspy-prompt-optimizer
    Tunes prompts iteratively using reflection and success metrics. Use for: optimize this prompt, dspy tune, improve prompt with reflection, `self-refine-loop`.
  • 100hk-refine
    Improve an output that isn't good enough (a reflection, plan, prompt, pipeline result) by an observe-hypothesize-change-rerun loop kept on disk. Triggers on: 'close the loop', 'this output isn't good enough', 'iterate on this', 'refine this output', 'improve this reflection', or /hk-refine.
  • 100self-critique
    WellForge self-critique pass — the ONE bounded review an agent runs on its own artifact before handing it to a human gate, to QE, or to the evaluator. Use whenever you are about to return a spec.md, plan.md, design.md, tasks.md or an implemented task, whether from an agent or…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.