@monoes/monomindcli 2.15.2 → 2.15.4

package/org-skills/adversarial-reviewer/SKILL.md

@@ -0,0 +1,246 @@
+---
+name: adversarial-reviewer
+description: "Adversarial code review that breaks the self-review monoculture. Use when you want a genuinely critical review of recent changes, before merging a PR, or when an AI reviewer is being too agreeable about code quality. Forces perspective shifts through hostile reviewer personas that catch blind spots the author's mental model shares with the reviewer."
+tags: ["engineering","testing"]
+tools: ["monograph_query","monograph_context","monograph_impact","monograph_suggest"]
+license: MIT
+source: https://github.com/alirezarezvani/claude-skills
+source_path: "engineering-team/skills/adversarial-reviewer"
+source_commit: 19392f7a08264ed00486a251f5b2098321771f94
+---
+# Adversarial Code Reviewer
+
+## Description
+
+Adversarial code review skill that forces genuine perspective shifts through three hostile reviewer personas (Saboteur, New Hire, Security Auditor). Each persona MUST find at least one issue — no "LGTM" escapes. Findings are severity-classified and cross-promoted when caught by multiple personas.
+
+## Features
+
+- **Three adversarial personas** — Saboteur (production breaks), New Hire (maintainability), Security Auditor (OWASP-informed)
+- **Mandatory findings** — Each persona must surface at least one issue, eliminating rubber-stamp reviews
+- **Severity promotion** — Issues caught by 2+ personas are promoted one severity level
+- **Self-review trap breaker** — Concrete techniques to overcome shared mental model blind spots
+- **Structured verdicts** — BLOCK / CONCERNS / CLEAN with clear merge guidance
+
+## Usage
+
+```
+/adversarial-review              # Review staged/unstaged changes
+/adversarial-review --diff HEAD~3  # Review last 3 commits
+/adversarial-review --file src/auth.ts  # Review a specific file
+```
+
+## Examples
+
+### Example: Reviewing a PR Before Merge
+
+```
+/adversarial-review --diff main...HEAD
+```
+
+Produces a structured report with findings from all three personas, deduplicated and severity-ranked, ending with a BLOCK/CONCERNS/CLEAN verdict.
+
+## Problem This Solves
+
+When Claude reviews code it wrote (or code it just read), it shares the same mental model, assumptions, and blind spots as the author. This produces "Looks good to me" reviews on code that a fresh human reviewer would flag immediately. Users report this as one of the top frustrations with AI-assisted development.
+
+This skill forces a genuine perspective shift by requiring you to adopt adversarial personas — each with different priorities, different fears, and different definitions of "bad code."
+
+## Table of Contents
+
+1. [Quick Start](#quick-start)
+2. [Review Workflow](#review-workflow)
+3. [The Three Personas](#the-three-personas)
+4. [Severity Classification](#severity-classification)
+5. [Output Format](#output-format)
+6. [Anti-Patterns](#anti-patterns)
+7. [When to Use This](#when-to-use-this)
+
+## Quick Start
+
+```
+/adversarial-review              # Review staged/unstaged changes
+/adversarial-review --diff HEAD~3  # Review last 3 commits
+/adversarial-review --file src/auth.ts  # Review a specific file
+```
+
+## Review Workflow
+
+### Step 1: Gather the Changes
+
+Determine what to review based on invocation:
+
+- **No arguments:** Run `git diff` (unstaged) + `git diff --cached` (staged). If both empty, run `git diff HEAD~1` (last commit).
+- **`--diff <ref>`:** Run `git diff <ref>`.
+- **`--file <path>`:** Read the entire file. Focus review on the full file rather than just changes.
+
+If no changes are found, stop and report: "Nothing to review."
+
+### Step 2: Read the Full Context
+
+For every file in the diff:
+1. Read the **full file** (not just the changed lines) — bugs hide in how new code interacts with existing code.
+2. Identify the **purpose** of the change: bug fix, new feature, refactor, config change, test.
+3. Note any **project conventions** from CLAUDE.md, .editorconfig, linting configs, or existing patterns.
+
+### Step 3: Run All Three Personas
+
+Execute each persona sequentially. Each persona MUST produce at least one finding. If a persona finds nothing wrong, it has not looked hard enough — go back and look again.
+
+**IMPORTANT:** Do not soften findings. Do not hedge. Do not say "this might be fine but..." — either it's a problem or it isn't. Be direct.
+
+### Step 4: Deduplicate and Synthesize
+
+After all three personas have reported:
+1. Merge duplicate findings (same issue caught by multiple personas).
+2. Promote findings caught by 2+ personas to the next severity level.
+3. Produce the final structured output.
+
+## The Three Personas
+
+### Persona 1: The Saboteur
+
+**Mindset:** "I am trying to break this code in production."
+
+**Priorities:**
+- Input that was never validated
+- State that can become inconsistent
+- Concurrent access without synchronization
+- Error paths that swallow exceptions or return misleading results
+- Assumptions about data format, size, or availability that could be violated
+- Off-by-one errors, integer overflow, null/undefined dereferences
+- Resource leaks (file handles, connections, subscriptions, listeners)
+
+**Review Process:**
+1. For each function/method changed, ask: "What is the worst input I could send this?"
+2. For each external call, ask: "What if this fails, times out, or returns garbage?"
+3. For each state mutation, ask: "What if this runs twice? Concurrently? Never?"
+4. For each conditional, ask: "What if neither branch is correct?"
+
+**You MUST find at least one issue. If the code is genuinely bulletproof, note the most fragile assumption it relies on.**
+
+---
+
+### Persona 2: The New Hire
+
+**Mindset:** "I just joined this team. I need to understand and modify this code in 6 months with zero context from the original author."
+
+**Priorities:**
+- Names that don't communicate intent (what does `data` mean? what does `process()` do?)
+- Logic that requires reading 3+ other files to understand
+- Magic numbers, magic strings, unexplained constants
+- Functions doing more than one thing (the name says X but it also does Y and Z)
+- Missing type information that forces the reader to trace through call chains
+- Inconsistency with surrounding code style or project conventions
+- Tests that test implementation details instead of behavior
+- Comments that describe *what* (redundant) instead of *why* (useful)
+
+**Review Process:**
+1. Read each changed function as if you've never seen the codebase. Can you understand what it does from the name, parameters, and body alone?
+2. Trace one code path end-to-end. How many files do you need to open?
+3. Check: would a new contributor know where to add a similar feature?
+4. Look for "the author knew something the reader won't" — implicit knowledge baked into the code.
+
+**You MUST find at least one issue. If the code is crystal clear, note the most likely point of confusion for a newcomer.**
+
+---
+
+### Persona 3: The Security Auditor
+
+**Mindset:** "This code will be attacked. My job is to find the vulnerability before an attacker does."
+
+**OWASP-Informed Checklist:**
+
+| Category | What to Look For |
+|----------|-----------------|
+| **Injection** | SQL, NoSQL, OS command, LDAP — any place user input reaches a query or command without parameterization |
+| **Broken Auth** | Hardcoded credentials, missing auth checks on new endpoints, session tokens in URLs or logs |
+| **Data Exposure** | Sensitive data in error messages, logs, or API responses; missing encryption at rest or in transit |
+| **Insecure Defaults** | Debug mode left on, permissive CORS, wildcard permissions, default passwords |
+| **Missing Access Control** | IDOR (can user A access user B's data?), missing role checks, privilege escalation paths |
+| **Dependency Risk** | New dependencies with known CVEs, pinned to vulnerable versions, unnecessary transitive dependencies |
+| **Secrets** | API keys, tokens, passwords in code, config, or comments — even "temporary" ones |
+
+**Review Process:**
+1. Identify every trust boundary the code crosses (user input, API calls, database, file system, environment variables).
+2. For each boundary: is input validated? Is output sanitized? Is the principle of least privilege followed?
+3. Check: could an authenticated user escalate privileges through this change?
+4. Check: does this change expose any new attack surface?
+
+**You MUST find at least one issue. If the code has no security surface, note the closest thing to a security-relevant assumption.**
+
+## Severity Classification
+
+| Severity | Definition | Action Required |
+|----------|-----------|-----------------|
+| **CRITICAL** | Will cause data loss, security breach, or production outage. Must fix before merge. | Block merge. |
+| **WARNING** | Likely to cause bugs in edge cases, degrade performance, or confuse future maintainers. Should fix before merge. | Fix or explicitly accept risk with justification. |
+| **NOTE** | Style issue, minor improvement opportunity, or documentation gap. Nice to fix. | Author's discretion. |
+
+**Promotion rule:** A finding flagged by 2+ personas is promoted one level (NOTE becomes WARNING, WARNING becomes CRITICAL).
+
+## Output Format
+
+Structure your review as follows:
+
+```markdown
+## Adversarial Review: [brief description of what was reviewed]
+
+**Scope:** [files reviewed, lines changed, type of change]
+**Verdict:** BLOCK / CONCERNS / CLEAN
+
+### Critical Findings
+[If any — these block the merge]
+
+### Warnings
+[Should-fix items]
+
+### Notes
+[Nice-to-fix items]
+
+### Summary
+[2-3 sentences: what's the overall risk profile? What's the single most important thing to fix?]
+```
+
+**Verdict definitions:**
+- **BLOCK** — 1+ CRITICAL findings. Do not merge until resolved.
+- **CONCERNS** — No criticals but 2+ warnings. Merge at your own risk.
+- **CLEAN** — Only notes. Safe to merge.
+
+## Anti-Patterns
+
+### What This Skill is NOT
+
+| Anti-Pattern | Why It's Wrong |
+|-------------|---------------|
+| "LGTM, no issues found" | If you found nothing, you didn't look hard enough. Every change has at least one risk, assumption, or improvement opportunity. |
+| Cosmetic-only findings | Reporting only whitespace/formatting while missing a null dereference is worse than no review at all. Substance first, style second. |
+| Pulling punches | "This might possibly be a minor concern..." — No. Be direct. "This will throw a NullPointerException when `user` is undefined." |
+| Restating the diff | "This function was added to handle authentication" is not a finding. What's WRONG with how it handles authentication? |
+| Ignoring test gaps | New code without tests is a finding. Always. Tests are not optional. |
+| Reviewing only the changed lines | Bugs live in the interaction between new code and existing code. Read the full file. |
+
+### The Self-Review Trap
+
+You are likely reviewing code you just wrote or just read. Your brain (weights) formed the same mental model that produced this code. You will naturally think it looks correct because it matches your expectations.
+
+**To break this pattern:**
+1. Read the code **bottom-up** (start from the last function, work backward).
+2. For each function, state its contract **before** reading the body. Does the body match?
+3. Assume every variable could be null/undefined until proven otherwise.
+4. Assume every external call will fail.
+5. Ask: "If I deleted this change entirely, what would break?" — if the answer is "nothing," the change might be unnecessary.
+
+## When to Use This
+
+- **Before merging any PR** — especially self-authored PRs with no human reviewer
+- **After a long coding session** — fatigue produces blind spots; this skill compensates
+- **When Claude said "looks good"** — if you got an easy approval, run this for a second opinion
+- **On security-sensitive code** — auth, payments, data access, API endpoints
+- **When something "feels off"** — trust that instinct and run an adversarial review
+
+## Cross-References
+
+- Related: `engineering-team/senior-security` — deep security analysis
+- Related: `engineering-team/code-reviewer` — general code quality review
+- Complementary: `ra-qm-team/` — quality management workflows

package/org-skills/agent-evaluation/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Context Engineering Agent Skills Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/org-skills/agent-evaluation/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: agent-evaluation
+description: "This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines."
+tags: ["ai-ml","testing"]
+tools: []
+license: MIT
+source: https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering
+source_path: "skills/evaluation"
+source_commit: 6dbe1a1d868eab51a3bc9011b0f55e2891513e40
+---
+# Evaluation Methods for Agent Systems
+
+Evaluate agent systems differently from traditional software because agents make dynamic decisions, are non-deterministic between runs, and often lack single correct answers. Build evaluation frameworks that account for these characteristics, provide actionable feedback, catch regressions, and validate that context engineering choices achieve intended effects.
+
+## When to Activate
+
+Activate this skill when:
+- Testing agent performance systematically
+- Validating context engineering choices
+- Measuring improvements over time
+- Catching regressions before deployment
+- Building quality gates for agent pipelines
+- Comparing different agent configurations
+- Evaluating production systems continuously
+
+Do not activate this skill for adjacent work owned by other skills:
+- Designing the LLM judge itself, pairwise comparison, judge calibration, or bias mitigation: `advanced-evaluation`.
+- Designing autonomous control surfaces, novelty gates, rollback, or PR approval boundaries: `harness-engineering`.
+- Debugging a specific context failure mode before measuring it: `context-degradation`.
+
+## Core Concepts
+
+Focus evaluation on outcomes rather than execution paths, because agents may find alternative valid routes to goals. Judge whether the agent achieves the right outcome via a reasonable process, not whether it followed a specific sequence of steps.
+
+Use multi-dimensional rubrics instead of single scores because one number hides critical failures in specific dimensions. Capture factual accuracy, completeness, citation accuracy, source quality, and tool efficiency as separate dimensions, then weight them for the use case.
+
+Use model-judged evaluation only after deterministic checks and rubrics are stable. When the work centers on judge prompts, pairwise comparison, calibration, or bias mitigation, switch to Advanced Evaluation.
+
+Run deterministic validation before LLM judgment whenever the artifact has machine-checkable structure. Schema validity, duplicate keys, rubric math, manifest sync, retrieval status, and required evidence paths should fail fast before an evaluator spends tokens or returns a subjective score.
+
+**Performance Drivers**
+
+Apply browsing-agent research when designing evaluation budgets: token usage, tool calls, and model choice can dominate measured performance variance (claim-evaluation-browsecomp-variance).
+
+| Factor | Variance Explained | Implication |
+|--------|-------------------|-------------|
+| Token usage | Primary driver | More exploration can improve performance until cost or context quality collapses |
+| Number of tool calls | Secondary driver | More tool use helps only when calls retrieve useful evidence |
+| Model choice | Secondary but multiplicative | Better models often use tokens and tools more efficiently |
+
+Act on these implications when designing evaluations:
+- **Set realistic token budgets**: Evaluate agents with production-realistic token limits, not unlimited resources.
+- **Compare model upgrades against token increases**: Better models may use tokens more efficiently than weaker models with larger budgets.
+- **Validate multi-agent architectures**: Extra agents add tokens and tool calls; evaluate them against single-agent baselines.
+
+## Detailed Topics
+
+### Evaluation Challenges
+
+**Handle Non-Determinism and Multiple Valid Paths**
+
+Design evaluations that tolerate path variation because agents may take completely different valid paths to reach goals. One agent might search three sources while another searches ten; both may produce correct answers. Avoid checking for specific steps. Instead, define outcome criteria (correctness, completeness, quality) and score against those, treating the execution path as informational rather than evaluative.
+
+**Test Context-Dependent Failures**
+
+Evaluate across a range of complexity levels and interaction lengths because agent failures often depend on context in subtle ways. An agent might succeed on simple queries but fail on complex ones, work well with one tool set but fail with another, or degrade after extended interaction as context accumulates. Include simple, medium, complex, and very complex test cases to surface these patterns.
+
+**Score Composite Quality Dimensions Separately**
+
+Break agent quality into separate dimensions (factual accuracy, completeness, coherence, tool efficiency, process quality) and score each independently because an agent might score high on accuracy but low on efficiency, or vice versa. Then compute weighted aggregates tuned to use-case priorities. This approach reveals which dimensions need improvement rather than averaging away the signal.
+
+### Evaluation Rubric Design
+
+**Build Multi-Dimensional Rubrics**
+
+Define rubrics covering key dimensions with descriptive levels from excellent to failed. Include these core dimensions and adapt weights per use case:
+
+- Factual accuracy: Claims match ground truth (weight heavily for knowledge tasks)
+- Completeness: Output covers requested aspects (weight heavily for research tasks)
+- Citation accuracy: Citations match claimed sources (weight for trust-sensitive contexts)
+- Source quality: Uses appropriate primary sources (weight for authoritative outputs)
+- Tool efficiency: Uses right tools a reasonable number of times (weight for cost-sensitive systems)
+
+**Convert Rubrics to Numeric Scores**
+
+Map dimension assessments to numeric scores (0.0 to 1.0), apply per-dimension weights, and calculate weighted overall scores. Set passing thresholds based on use-case requirements, typically 0.7 for general use and 0.9 for high-stakes applications. Store individual dimension scores alongside the aggregate because the breakdown drives targeted improvement.
+
+### Evaluation Methodologies
+
+**Use LLM-as-Judge for Scale**
+
+Build LLM-based evaluation prompts that include: clear task description, the agent output under test, ground truth when available, an evaluation scale with explicit level descriptions, and a request for structured judgment with reasoning. LLM judges provide consistent, scalable evaluation across large test sets. Use a different model family than the agent being evaluated to avoid self-enhancement bias.
+
+**Supplement with Human Evaluation**
+
+Route edge cases, unusual queries, and a random sample of production traffic to human reviewers because humans notice hallucinated answers, system failures, and subtle biases that automated evaluation misses. Track patterns across human reviews to identify systematic issues and feed findings back into automated evaluation criteria.
+
+**Apply End-State Evaluation for Stateful Agents**
+
+For agents that mutate persistent state (files, databases, configurations), evaluate whether the final state matches expectations rather than how the agent got there. Define expected end-state assertions and verify them programmatically after each test run.
+
+### Test Set Design
+
+**Select Representative Samples**
+
+Start with small samples (20-30 cases) during early development when changes have dramatic impacts and low-hanging fruit is abundant. Scale to 50+ cases for reliable signal as the system matures. Sample from real usage patterns, add known edge cases, and ensure coverage across complexity levels.
+
+**Stratify by Complexity**
+
+Structure test sets across complexity levels to prevent easy examples from inflating scores:
+- Simple: single tool call, factual lookup
+- Medium: multiple tool calls, comparison logic
+- Complex: many tool calls, significant ambiguity
+- Very complex: extended interaction, deep reasoning, synthesis
+
+Report scores per stratum alongside overall scores to reveal where the agent actually struggles.
+
+### Context Engineering Evaluation
+
+**Validate Context Strategies Systematically**
+
+Run agents with different context strategies on the same test set and compare quality scores, token usage, and efficiency metrics. This isolates the effect of context engineering from other variables and prevents anecdote-driven decisions.
+
+**Run Degradation Tests**
+
+Test how context degradation affects performance by running agents at different context sizes. Identify performance cliffs where context becomes problematic and establish safe operating limits. Feed these limits back into context management strategies.
+
+### Continuous Evaluation
+
+**Build Automated Evaluation Pipelines**
+
+Integrate evaluation into the development workflow so evaluations run automatically on agent changes. Track results over time, compare versions, and block deployments that regress on key metrics.
+
+**Monitor Production Quality**
+
+Sample production interactions and evaluate them continuously. Set alerts for quality drops below warning (0.85 pass rate) and critical (0.70 pass rate) thresholds. Maintain dashboards showing trend analysis over time windows to detect gradual degradation.
+
+## Practical Guidance
+
+### Building Evaluation Frameworks
+
+Follow this sequence to build an evaluation framework, because skipping early steps leads to measurements that do not reflect real quality:
+
+1. Define quality dimensions relevant to the use case before writing any evaluation code, because dimensions chosen later tend to reflect what is easy to measure rather than what matters.
+2. Create rubrics with clear, descriptive level definitions so evaluators (human or LLM) produce consistent scores.
+3. Build test sets from real usage patterns and edge cases, stratified by complexity, with at least 50 cases for reliable signal.
+4. Implement automated evaluation pipelines that run on every significant change.
+5. Establish baseline metrics before making changes so improvements can be measured against a known reference.
+6. Run evaluations on all significant changes and compare against the baseline.
+7. Track metrics over time for trend analysis because gradual degradation is harder to notice than sudden drops.
+8. Supplement automated evaluation with human review on a regular cadence.
+9. Separate deterministic validation failures from quality judgments so invalid artifacts cannot be laundered by a favorable LLM score.
+
+### Avoiding Evaluation Pitfalls
+
+Guard against these common failures that undermine evaluation reliability:
+
+- **Overfitting to specific paths**: Evaluate outcomes, not specific steps, because agents find novel valid paths.
+- **Ignoring edge cases**: Include diverse test scenarios covering the full complexity spectrum.
+- **Single-metric obsession**: Use multi-dimensional rubrics because a single score hides dimension-specific failures.
+- **Neglecting context effects**: Test with realistic context sizes and histories rather than clean-room conditions.
+- **Skipping human evaluation**: Automated evaluation misses subtle issues that humans catch reliably.
+
+## Examples
+
+**Example 1: Simple Evaluation**
+```python
+def evaluate_agent_response(response, expected):
+    rubric = load_rubric()
+    scores = {}
+    for dimension, config in rubric.items():
+        scores[dimension] = assess_dimension(response, expected, dimension)
+    overall = weighted_average(scores, config["weights"])
+    return {"passed": overall >= 0.7, "scores": scores}
+```
+
+**Example 2: Test Set Structure**
+
+Test sets should span multiple complexity levels to ensure comprehensive evaluation:
+
+```python
+test_set = [
+    {
+        "name": "simple_lookup",
+        "input": "What is the capital of France?",
+        "expected": {"type": "fact", "answer": "Paris"},
+        "complexity": "simple",
+        "description": "Single tool call, factual lookup"
+    },
+    {
+        "name": "medium_query",
+        "input": "Compare the revenue of Apple and Microsoft last quarter",
+        "complexity": "medium",
+        "description": "Multiple tool calls, comparison logic"
+    },
+    {
+        "name": "multi_step_reasoning",
+        "input": "Analyze sales data from Q1-Q4 and create a summary report with trends",
+        "complexity": "complex",
+        "description": "Many tool calls, aggregation, analysis"
+    },
+    {
+        "name": "research_synthesis",
+        "input": "Research emerging AI technologies, evaluate their potential impact, and recommend adoption strategy",
+        "complexity": "very_complex",
+        "description": "Extended interaction, deep reasoning, synthesis"
+    }
+]
+```
+
+**Example 3: Deterministic gate before model judgment**
+```python
+def evaluate_pr_candidate(candidate):
+    structure = run_validate_repo(candidate)
+    if not structure.ok:
+        return {"passed": False, "reason": "deterministic validation failed", "details": structure.errors}
+
+    quality = run_rubric_eval(candidate)
+    return {"passed": quality.overall >= 0.8, "scores": quality.dimensions}
+```
+
+**Example 4: Quality gate dimensions**
+```yaml
+gate:
+  deterministic:
+    - schema_valid
+    - required_files_present
+    - no_duplicate_ids
+  quality:
+    factual_accuracy: min 0.85
+    completeness: min 0.80
+    source_traceability: min 0.90
+```
+
+## Guidelines
+
+1. Use multi-dimensional rubrics, not single metrics
+2. Evaluate outcomes, not specific execution paths
+3. Cover complexity levels from simple to complex
+4. Test with realistic context sizes and histories
+5. Run evaluations continuously, not just before release
+6. Supplement LLM evaluation with human review
+7. Track metrics over time for trend detection
+8. Set clear pass/fail thresholds based on use case
+
+## Gotchas
+
+1. **Overfitting evals to specific code paths**: Tests pass but the agent fails on slight input variations. Write eval criteria against outcomes and semantics, not surface patterns, and rotate test inputs periodically.
+2. **LLM-judge self-enhancement bias**: Models rate their own outputs higher than independent judges do. Use a different model family as the evaluation judge than the model being evaluated.
+3. **Test set contamination**: Eval examples leak into training data or prompt templates, inflating scores. Keep eval sets versioned and separate from any data used in prompts or fine-tuning.
+4. **Metric gaming**: Optimizing for the metric rather than actual quality produces agents that score well but disappoint users. Cross-validate automated metrics against human judgments regularly.
+5. **Single-dimension scoring**: One aggregate number hides critical failures in specific dimensions. Always report per-dimension scores alongside the overall score, and fail the eval if any single dimension falls below its minimum threshold.
+6. **Eval set too small**: Fewer than 50 examples produces unreliable signal with high variance between runs. Scale the eval set to at least 50 cases and report confidence intervals.
+7. **Not stratifying by difficulty**: Easy examples inflate overall scores, masking failures on hard cases. Report scores per complexity stratum and weight the overall score to prevent easy-case dominance.
+8. **Treating eval as one-time**: Evaluation must be continuous, not a launch gate. Agent quality drifts as models update, tools change, and usage patterns evolve. Run evals on every change and on a regular production cadence.
+
+## Integration
+
+This skill owns outcome measurement and quality gates. Adjacent skills own specialized evaluator design and control-loop governance:
+
+- `advanced-evaluation`: LLM-as-judge prompt design, pairwise comparison, calibration, and bias mitigation.
+- `harness-engineering`: locked evaluators, editable surfaces, rollback, and human approval boundaries.
+- `context-degradation`: detecting and measuring degradation patterns.
+- `context-optimization`: measuring token, cost, latency, and quality effects of optimizations.
+- `multi-agent-patterns`: evaluating coordination quality and parallelization trade-offs.
+- `tool-design`: evaluating tool selection and recovery effectiveness.
+- `memory-systems`: evaluating memory retrieval and retention quality.
+
+## References
+
+Internal reference:
+- [Metrics Reference](./references/metrics.md) - Read when: designing specific evaluation metrics, choosing scoring scales, or implementing weighted rubric calculations
+
+Internal skills:
+- All other skills connect to evaluation for quality measurement
+
+External resources:
+- LLM evaluation benchmarks - Read when: selecting or building benchmark suites for agent comparison
+- Agent evaluation research papers - Read when: adopting new evaluation methodologies or validating current approach
+- Production monitoring practices - Read when: setting up alerting, dashboards, or sampling strategies for live systems
+
+---
+
+## Skill Metadata
+
+**Created**: 2025-12-20
+**Last Updated**: 2026-05-15
+**Author**: Agent Skills for Context Engineering Contributors
+**Version**: 1.2.0