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.
- Author
- nexadevapp ↗
- Repository
- nexa-claude-skills-marketplace ↗
- Licence
- Apache-2.0
- Last repository change
- 25.09.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 25.09.2026, without references to retired models or APIs.
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
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
- Instructions
- DO NOT
- Nexa Rules Gate
- Evaluation Dimensions
- Workflow
- Output Format
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
| Repository | Score | Licence |
|---|---|---|
| This page · nexadevapp/nexa-claude-skills-marketplace | 100 | Apache-2.0 |
| skillberry-ai/cap-evolve | 100 | Apache-2.0 |
| q00/ouroboros | 100 | MIT |
| ghaida/intent | 100 | CC0-1.0 |
| manykind-ai/plugin | 100 | MIT |
| minhuw/claude-writer | 100 | MIT |
| sharpdeveye/maestro | 100 | MIT |
| suboss87/FDEOps | 90 | MIT |
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.