← back to home
Guide — no install required

EPAV in Cursor

nexus ships its workflow as Claude Code skills, but the method behind it — Evaluate → Plan → Apply → Validate — is tool-agnostic. This guide gives Cursor users the principles, how they map onto Cursor's own features, and an optional one-file setup for the nexus MCP tools.

Why a Guide, Not a Plugin

Cursor already has the building blocks EPAV needs: Plan Mode with an approval step, project rules, native AGENTS.md support, and MCP. What it doesn't enforce is the discipline — orient before planning, never code without an approved plan, stay in scope, and don't call it done without evidence. That discipline is the valuable part of nexus, and it fits in one rule file.

Using Claude Code? You don't need this page — nexus init installs everything. See the docs.

The EPAV Principles

One task at a time, four steps, one human gate. Each step has a single job and a clear exit.

EVALUATE → PLAN → [human approves] → APPLY → VALIDATE

1. Evaluate — orient before deciding anything

2. Plan — a blueprint a human approves

3. Apply — implement exactly the plan

4. Validate — done means proven, not claimed

EPAV → Cursor Features

StepUse in CursorNotes
EvaluatePlan ModePlan Mode already asks clarifying questions and researches the codebase before planning — ask it for the Evaluate summary first, in the same session.
PlanPlan ModeIts review-then-build step is the EPAV gate. Edit the plan in chat or as markdown until it's right; only then click build. Plans save to your home directory — use "Save to workspace" to keep one with the project.
ApplyAgent (build the plan)The EPAV rule keeps it inside the approved steps.
ValidateAgentRun the build and tests; check each criterion with evidence.
StandardsAGENTS.md / .cursor/rules/Cursor reads AGENTS.md natively — nexus's generate_project_rules tool writes one.

Switch modes with Shift+Tab in the chat input, or the mode picker.

The EPAV Rule

Save this as .cursor/rules/epav.mdc and commit it. alwaysApply: true puts it in every Agent session, so the whole team works the same way.

---
description: EPAV workflow — evaluate, plan, apply, validate
alwaysApply: true
---

# EPAV workflow

Work one task at a time through four steps. Never skip the gate.

1. EVALUATE — Before planning, read the task and its acceptance
   criteria, AGENTS.md, the relevant architecture doc, and
   knowledge/. Output only:
   Task / Touches / Depends on / Constraints / Risk.

2. PLAN — Numbered steps, file by file, with what changes and why.
   List files created/modified/deleted and what references them.
   Then STOP. Write no code until the user explicitly approves
   (in Plan Mode, clicking build is the approval).

3. APPLY — Implement exactly the approved steps, in order. No extra
   features or unrelated refactors. If the plan turns out wrong,
   stop and say "Discovered: X — outside the plan. Revise?"

4. VALIDATE — Run build, tests and type check; they must pass. Mark
   each acceptance criterion PASS / FAIL / PARTIAL with evidence.
   Fix [BLOCKER] and [FIX NOW] issues before finishing; log
   [BACKLOG] items to knowledge/retros/. Never claim done without
   evidence.

Extra work found along the way goes to knowledge/retros/, not into
the current task.

Copy-Paste Prompts

With the rule in place, these are all you need. Paste into Agent chat.

Evaluate (Plan Mode)

Evaluate this task — do not plan or write code yet:
<task description, or path to the task CSV row>
Output the EVALUATE summary only.

Plan (Plan Mode)

Write the EPAV plan for this task: numbered steps, files
created/modified/deleted, blast radius, constraints. Then stop.

Apply (after you approve the plan)

Build the approved plan exactly. Stop and ask if anything
needs to go outside it.

Validate (Agent)

Validate: run the build and tests, mark every acceptance
criterion PASS/FAIL/PARTIAL with evidence, fix all BLOCKER and
FIX NOW issues, and log BACKLOG items to knowledge/retros/.
Want /evaluate-style slash commands? Cursor turns any skill into one: put the prompt in .cursor/skills/evaluate/SKILL.md with name: evaluate and a description in its frontmatter (the folder name must match name). Add disable-model-invocation: true so it only runs when you type /evaluate, never on Agent's own initiative.

Optional: the nexus MCP Tools

The nexus MCP server works in Cursor unchanged. Requires uv. Create .cursor/mcp.json:

{
  "mcpServers": {
    "nexus": {
      "type": "stdio",
      "command": "uvx",
      "args": ["--refresh", "--from", "nexus-dev-toolkit", "nexus-mcp"]
    }
  }
}

Make sure the nexus server is toggled on under Customize in the sidebar. By default Agent asks your approval before each MCP tool call. Agent can then call:

ToolEPAV stepWhat it does
load_taskEvaluateLoads a task row (user story, description, acceptance criteria, dependencies) from a CSV, with a knowledge-graph query on it if one is built.
ingest_architecture_docEvaluateExtracts stack, data model, auth, error format, security rules and ADRs from an architecture doc.
generate_project_rulesSetupWrites AGENTS.md and the knowledge/ structure from an architecture doc. Cursor reads AGENTS.md automatically.
resolve_package_versionsApplyResolves exact pinned versions with the real package manager in a temp dir, so manifests are deterministic.

Optional: Knowledge Graph Hook

If you use graphify, keep the graph current after every Agent edit with .cursor/hooks.json:

{
  "version": 1,
  "hooks": {
    "afterFileEdit": [
      { "command": "graphify update . --force 2>/dev/null || true" }
    ]
  }
}

Hooks only run in trusted workspaces, and afterFileEdit fires on Agent edits only — Tab completions don't trigger it. codegraph syncs itself and needs no hook.

What You Don't Get vs. Claude Code

built by CoderStudio Labs