evaluator

Verify Nova code implementations through adversarial static and execution-based evaluation.

2|1|Updated Mar 26, 2026
One-click install
npx skills add https://github.com/TeamSPWK/nova --skill evaluator-teamspwk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: evaluator
Source: https://github.com/TeamSPWK/nova/tree/main/.claude/skills/evaluator
Command: npx skills add https://github.com/TeamSPWK/nova --skill evaluator-teamspwk

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps verify code implementations from an adversarial perspective to ensure outcomes reflect actual runtime behavior rather than the agent's self-reports.

Core Features & Use Cases

  • Independent subagent adversarial evaluation during on-demand flows such as /nova:run, /nova:check, and /nova:review, including sprint completions and pre-commit gates.
  • Layered verification spanning static analysis, semantic alignment, and execution-based validation to ensure design-implementation integrity.
  • Observability hooks and metrics integration (e.g., events logging, NOVA-STATE updates) to enable traceable judgments and post-hoc audits.
  • Safe-guarded generator-evaluator separation with enforced non-modification of code, reinforced by governance hooks and actionability-focused remediation guidance.

Quick Start

Invoke the evaluator on your latest changes to obtain a verdict and concrete remediation steps.

Frequently Asked Questions about evaluator

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I perform adversarial code validation to verify runtime behavior?

Adversarial code validation is performed by an independent subagent that checks implementations against actual runtime behavior rather than self-reports, applying layered verification across static analysis, semantic alignment, and execution-based validation.

When do I need gate-keeping evaluation for sprint completions and pre-commit gates?

Gate-keeping evaluation is needed during on-demand flows like sprint completions and pre-commit gates to enforce independence and traceability, ensuring code changes meet rigorous design-implementation integrity standards before proceeding.

What's the best way to enforce generator-evaluator separation during code review?

Enforcing generator-evaluator separation requires a dedicated evaluator workflow that strictly prohibits code modification, providing governance hooks and actionable remediation guidance while maintaining independence from the generation process.

Can I use an independent subagent for static analysis and semantic review?

Yes, an independent subagent can perform static analysis, semantic alignment, and execution-based validation simultaneously, applying adversarial perspectives to verify that outcomes reflect actual runtime behavior across various project phases.

How does traceability work with observability hooks and events logging during evaluation?

Traceability works through observability hooks and metrics integration that log events and update state, enabling traceable judgments and post-hoc audits to verify the evaluator workflow's integrity and track remediation actions.

Why does adversarial evaluation focus on actual runtime behavior instead of self-reports?

Adversarial evaluation focuses on runtime behavior because agent self-reports may not reflect true execution outcomes, so verifying through independent static, semantic, and execution-based validation ensures rock-solid quality assurance.