Skip to content
Skills Library
Programming · Review & audit

evaluate

/evaluate

Evaluates whether an implementation satisfies its use case specification and design artifact. Checks functional conformance, design conformance, and completeness with an independent perspective. Use when the user asks to "evaluate the implementation", "check if it matches the spec", "validate the work", or mentions evaluation, conformance check, or spec validation.

Licence
Apache-2.0
Last repository change
25.09.2026

Assessment and security

100/ 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.
Content35 / 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 25.09.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Evaluates whether an implementation satisfies its use case specification and design artifact. Checks functional conformance, design conformance, and completeness with an independent perspective. Use when the user asks to "evaluate the implementation", "check if it matches the spec", "validate the work", or mentions evaluation, conformance check, or spec validation.

Triggers from the description

evaluate the implementationcheck if it matches the specvalidate the work
Original author description

Evaluates whether an implementation satisfies its use case specification and design artifact. Checks functional conformance, design conformance, and completeness with an independent perspective. Use when the user asks to "evaluate the implementation", "check if it matches the spec", "validate the work", or mentions evaluation, conformance check, or spec validation.

How it works

  1. Instructions
  2. DO NOT
  3. Nexa Rules Gate
  4. Evaluation Dimensions
  5. Workflow
  6. Output Format
Original SKILL.md headings · 134 lines, 646 words
SKILL.md preview
---
name: evaluate
description: >
  Evaluates whether an implementation satisfies its use case specification and design
  artifact. Checks functional conformance, design conformance, and completeness with
  an independent perspective. Use when the user asks to "evaluate the implementation",
  "check if it matches the spec", "validate the work", or mentions evaluation,
  conformance check, or spec validation.
context: fork
---

# Evaluate Implementation

## Instructions

Evaluate the implementation of $ARGUMENTS against its specification and design artifact.
$ARGUMENTS is a use case ID (`UC-XXX`) or a technical task ID (`TT-XXX`).

You are an independent evaluator. You have NOT seen the implementation process or the
decisions that led to the current code. Your job is to compare what was specified against
what was built and report any gaps.

## DO NOT

- Assume that passing tests mean the implementation is correct
- Review code quality or style (that is the code reviewer's job)
- Suggest improvements beyond what the specification requires
- Skip checking Alternative Flows or edge cases
- Accept partial implementations without flagging missing pieces

## Nexa Rules Gate

Read and follow `${CLAUDE_PLUGIN_ROOT}/shared/readiness/NEXA_RULES_GATE.md`.

## Evaluation Dimensions

### 1. Specification Conformance

Compare the implementation against the use case specification or technical task:

**For Use Cases (UC-XXX):**
- Read the specification from `docs/use_cases/`
- Verify every Main Success Scenario step is implemented
- Verify every Alternative Flow is handled
- Verify every Business Rule is enforced
- Verify Preconditions are validated
- Verify Success and Failure Postconditions are reachable

**For Technical Tasks (TT-XXX):**
- Read the specification from `docs/technical_tasks/`
- Verify every acceptance criterion is met
- Verify the described behavior is implemented

### 2. Design Conformance

If a design artifact exists in `docs/designs/`, compare the implementation against it:

- Are all specified screens implemented?
- Does the layout match the design specification?
- Are all specified components present?
- Do user actions trigger the correct results?
- Are all states handled (default, loading, empty, error, success)?
- Does the navigation flow match the design?

If no design artifact exists, skip this dimension and note it in the report.

**Design Rules Compliance:** If `docs/designs/DESIGN_RULES.md` exists, verify the
implementation follows every rule defined there (e.g., shared header/footer is present,
navigation patterns are consistent). Non-compliance with design rules is a defect.

### 3. Completeness

- Are there specification requirements with no corresponding implementation?
- Are there implemented features with no corresponding specification (scope creep)?
- Are entity model attributes correctly reflected in the UI and data layer?

## Workflow

1. Read the specification:
   - For **UC-XXX**: Read from `docs/use_cases/`
   - For **TT-XXX**: Read from `docs/technical_tasks/`
2. Read the design artifact from `docs/designs/` (if it exists)
3. Read project design rules from `docs/designs/DESIGN_RULES.md` (if it exists)
4. Read the entity model from `docs/entity_model.md` (if applicable)
5. Identify all implementation files related to this use case or task
6. Trace each specification requirement to its implementation
7. Trace each design element to its implementation (if design exists)
8. Check for unspecified behavior in the implementation
9. Produce a structured evaluation report

## Output Format

```markdown
# Evaluation: [UC-XXX / TT-XXX]

## Verdict

[PASS | PASS WITH OBSERVATIONS | FAIL]

[1-2 sentence summary of the evaluation result]

## Specification Conformance

### Main Success Scenario

| Step | Specification | Implemented? | Notes |
|------|--------------|--------------|-------|
| 1 | [Step description] | Yes / No / Partial | [Details] |

### Alternative Flows

| Flow | Trigger | Implemented? | Notes |
|------|---------|--------------|-------|
| A1 | [Trigger] | Yes / No / Partial | [Details] |

### Business Rules

| Rule | Description | Enforced? | Notes |
|------|-------------|-----------|-------|
| BR-001 | [Rule] | Yes / No / Partial | [Details] |

## Design Conformance

[If no design artifact exists: "No design artifact found in docs/designs/. Skipped."]

| Screen | Components Present? | States Handled? | Navigation Correct? | Notes |
|--------|-------------------|-----------------|-------------------|-------|
| [Screen name] | Yes / No / Partial | Yes / No / Partial | Yes / No | [Details] |

## Completeness

### Missing from Implementation

- [Specification requirement that has no implementation]

### Unspecified in Implementation (Scope Creep)

- [Implemented feature that has no specification backing]

## Recommendations

- [Actionable items to reach PASS, if verdict is not PASS]
```

Versions

RepositoryScoreLicence
This page · nexadevapp/nexa-claude-skills-marketplace100Apache-2.0
skillberry-ai/cap-evolve100Apache-2.0
q00/ouroboros100MIT
ghaida/intent100CC0-1.0
manykind-ai/plugin100MIT
minhuw/claude-writer100MIT
sharpdeveye/maestro100MIT
suboss87/FDEOps90MIT

Database snapshot: 13.11.2026 · package version 393e365c3c43 (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

  • 95sdd-verify
    Use when verifying that an implementation matches a change's SDD artifacts. Triggers: "verify", "check implementation", "did I implement everything", "verify the change", "is implementation complete", "check conformance".
  • 100spec-verify
    Check that an OpenSpec change's implementation actually matches its spec, before anything is archived - artifact validity via `openspec validate --strict`, the repo's own verify gate run for real, and scenario-by-scenario conformance against the spec delta. Read-only: it…
  • 100verify-impl
    Forensic audit of an implementation against its authoritative specification. Use whenever a specification document and an implementation are both in scope and the user asks any conformance question - even when not phrased explicitly: 'does this code match the spec', 'verify this…
  • 100code-review
    Reviews code changes for quality, correctness, security, and maintainability with an independent perspective. Use when the user asks to "review the code", "check my changes", "review the implementation", or mentions code review, PR review, or quality check.
  • 90openspec-verify-change
    Verifies that an implementation matches its OpenSpec change's artifacts — completeness (tasks, spec coverage), correctness (requirement and scenario coverage), and coherence (design adherence, pattern consistency) — post-implementation, before archiving. Use for "verify this…
  • 86surface-completeness
    Use to check UI coverage, design compliance, and docs during frontend changes.

Feedback and reports

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