Skip to main content
skill Claude Code CX Codex Cursor GitHub Copilot

ce-pov — Claude Code skill: grade solutions against project facts

Forms a grounded verdict on whether an external solution, document, or approach fits your project. Judges only by evidence from your codebase and constraints.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EveryInc/compound-engineering-plugin --skill ce-pov -a claude-code
Open on GitHub

What ce-pov does

ce-pov delivers a defensible point of view on three kinds of questions: adopt an external solution, assess a document holistically, or take a position on competing approaches. The skill stays read-only within your project context and never issues a verdict without evidence from code, ADRs, or design docs.

The workflow runs in three phases. First, the skill classifies the question from your prompt and conversation. Then it gathers facts from the project and external sources, checks them against grounding standards, and returns a decision with all material tradeoffs and conditions stated. If context is missing, it returns a blocker explaining what to clarify.

For complex verdicts, the skill can run a panel of independent models to consult their views and reconcile conflicts. When the judgment rests on unresolved behavior or design rationale, the skill calls ce-explain and verifies the findings by the same evidence standard.

What it helps with

  • grade whether a third-party library fits your architecture and constraints
  • give a verdict on a document or RFC before voting on a change
  • compare multiple proposed approaches and pick one with reasoning
  • get a grounded opinion on the risk of migrating to a new tool
  • resolve disagreements between team members' competing viewpoints

Example prompts for the agent

  • Should we migrate from axios to fetch given our bundle size limits — use project evidence
  • Grade this microservices design against our ADRs and load assumptions
  • Compare three caching strategies and recommend one for our data model

How to install ce-pov

1Skills CLI (Vercel)

npx skills add EveryInc/compound-engineering-plugin --skill ce-pov -a claude-code

2Manually: put the files in place

~/.claude/skills/ce-pov/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ce-pov/

From the same set21

The whole set →
ce-brainstorm EveryInc Turns vague ideas into a structured requirements plan through dialogue. Separates product decisions from code. Claude Code CX Codex Cursor +1 3,900installs ce-compound EveryInc A skill that captures non-obvious reasoning from solved problems as durable project knowledge. Use it when the final code works but the logic behind it might vanish when the next person reads the code. Claude Code CX Codex Cursor +1 3,700installs ce-plan EveryInc Builds structured technical implementation plans without touching production code. Useful when scoping features before passing work to execution agents. Claude Code CX Codex Cursor +1 3,700installs ce-code-review EveryInc Reviews a named diff or pull request for bugs, regressions, tests, and project standards. Use it for a current branch review or a specific PR. Claude Code CX Codex Cursor +1 3,700installs ce-work EveryInc Executes a plan document or build spec end-to-end with local verification. Ideal for implementing features without reopening architectural debates. Claude Code CX Codex Cursor +1 3,600installs ce-doc-review EveryInc This skill reviews requirements, plans, and specs through role-based reviewers. Use it to catch consequential issues in an existing document and apply fixes within the granted authority. Claude Code CX Codex Cursor +1 3,600installs ce-debug EveryInc Finds the root cause of a bug from trigger to symptom and applies a test-first fix. Useful when investigating broken behavior or failing CI logs. Claude Code CX Codex Cursor +1 3,500installs lfg EveryInc Takes a request from intake to a finished result and opens a pull request for code changes. Use it when the user explicitly wants autonomous end-to-end work. Claude Code CX Codex Cursor +1 3,500installs

Similar

vector-hyperbolic ruvnet Places hierarchical data in the Poincaré ball: radius from tree depth, direction from a text embedding. For dependency trees, ontologies, class hierarchies. Claude Code CX Codex Cursor +1 724installs convex-create-component convex A skill to design and build reusable Convex components with isolated tables and a clear API boundary. Useful when you need to extract backend logic into a self-contained module or package an integration that owns its own data. Claude Code CX Codex Cursor +1 130,600installs debug Yeachan-Heo Diagnoses broken OMC sessions, workflow failures, and repo state issues using traces and targeted reproduction. Claude Code CX Codex Cursor +1 629installs router gamedev-skills Dispatches game development tasks to specialized skills by detecting the project engine and classifying gameplay or shipping workflows. Claude Code CX Codex Cursor +1 6,400installs solid vercel-labs Skill to render JSON-specs into reactive SolidJS components. Use it when building UI catalogs, wiring providers, or debugging Solid reactivity patterns. Claude Code CX Codex Cursor +1 1,100installs redux vercel-labs A Redux adapter for json-render: it points the renderer at a store slice instead of its own state. Useful when app state already lives in Redux. Claude Code CX Codex Cursor +1 1,100installs setup-matt-pocock-skills Matt Pocock This skill configures a repository for Matt Pocock's engineering skills by setting its issue tracker, triage labels, and domain docs layout. Run it before using the other skills. Claude Code 1,052,851installs to-tickets Matt Pocock Turns a plan, spec, or conversation into small end-to-end tickets with explicit blockers. Use it to agree on the work breakdown before tickets go to a tracker. Claude Code 711,230installs

Questions about ce-pov

How do I install ce-pov in Claude Code?

Run npx skills add EveryInc/compound-engineering-plugin --skill ce-pov -a claude-code, then open ~/.claude/skills/ce-pov/SKILL.md to set up.

How is ce-pov different from asking an AI for advice?

ce-pov judges only by evidence from your project—code, ADRs, design docs. It refuses to judge without grounding and discloses all tradeoffs the verdict depends on.

What if the skill says context is missing?

The facts needed for a verdict are not in your codebase and the skill cannot find them reliably. Tell it where they live or provide context in the conversation.

Source text

SKILL.md · MIT
---
name: ce-pov
description: "Judge a supplied subject against the project's evidence and constraints. Use when assessing an external-adoption question, a holistic take on a document, or a supplied approach set. Use for an oracle panel to consult other models and reconcile their opinions. Use ce-explain for understanding and ce-doc-review for findings review."
argument-hint: "[question, document, or approaches] [cross-check] — or bare"
---

# Form a Point of View

Produce a decisive, project-grounded point of view in the subject's own shape: a **graded verdict** on an external-adoption question, a **holistic take** on a document, or a **position** on a supplied approach set. The subject is whatever this skill was invoked with, in the prompt or the conversation. Stay read-only while forming and reconciling the POV. You are done when the POV is delivered with its attribution and required disclosure, or when an explicit blocker is returned. Use `ce-bakeoff` to develop competing solutions, `ce-ideate` to explore opportunities, or `ce-brainstorm` to establish goals. **The year is 2026**, for source recency.


## Grounding is not optional

**Never issue a POV you did not earn against the project's own context.** Every subject must meet the minimum project evidence (the **project floor**) in `references/method.md`. An external-adoption verdict must also meet the full external evidence bar there. A document or approach-set POV must verify against outside sources any external claim its bottom line depends on. Nothing the conversation asserts substitutes for grounding.

## Consumer and interaction

Deliver a supported position in the form the intended consumer can use. Lead with the decision and preserve the evidence, material tradeoffs, uncertainty, and conditions that determine it. Make identifiers understandable without requiring the reader to reopen the subject. In progress updates, say in plain words what you are checking and which model or helper is checking it. Never name this skill's machinery there (payloads, scouts, dossiers, tiers, round numbers, scratch files).

When contributing to an ongoing workflow, return the result and leave continuation to its owner, the calling workflow. Do not add follow-up or panel offers to that return. An explicit oracle or named-peer request still runs the panel, including when it comes from a calling workflow.

## Identify the question and return the result

Identify the question from the request and conversation, then look up facts you can verify. Do not interview the user to work out what to assess. If missing information would change the recommendation and you cannot find it, return **Blocked — missing context**. Explain what is missing, why it matters, and what would resolve it. The calling agent decides whether to ask for clarification or take another action. This applies whether the user invokes `ce-pov` directly or another agent calls it; no separate non-interactive mode is needed.

## Artifact Root

Resolve `<root>` the first time you compose a `<root>/` path; a read of `<root>/solutions/` counts as composing one. Pass the resolved path to scouts, never the config. A non-git project has no `<root>`, so its prior-decision scan uses local ADRs and design docs instead.

<!-- ce-docs-root:start -->
**Resolve the CE artifact root `<root>` before composing any artifact path.**

- **Read** `docs_root` from `<repo-root>/.compound-engineering/config.yaml` only (`<repo-root>` = `git rev-parse --show-toplevel`). Do not read it from `config.local.yaml`. Unset -> `<root>` is `docs`, exactly as before.
- **Validate** a set value: a repo-relative directory whose real, symlink-resolved path stays inside the repo and is neither the repo root nor under `.git/`. Otherwise stop with an error naming `docs_root` and the value -- never fall back to `docs`.
- **Use** `<root>` as the sole artifact location: create it if absent, compose each path as `<root>/<subdir>` with this skill's own subdirectory, and never also read `docs`.
<!-- ce-docs-root:end -->

### Phase 0: Frame and Classify

**Read `references/intake.md` now, before any grounding.** It defines the output mode, what a calling workflow passes in, orientation and framing, sizing, and what to do when the question has no bounded answer. Settle the subject and the POV intent there (adopt / migrate / compare / is-this-our-problem / Document-take / Approach-set / explainer); an intent that belongs to another skill finishes at intake, and one that continues records how reversible the decision is. Read `references/boundaries.md` when this skill's fit is in doubt.

### Phase 1: Ground

**Read `references/grounding.md` now, before grounding by either path.** It defines the model tiers (the POV reasoning itself is never dispatched), where scratch files may go, what scouts receive and how many run, which capabilities gate which steps, and how grounded facts are kept apart from unconfirmed ones.

Send scouts directly to candidate-specific current evidence, never a generic repo profile. They search in their own context and return a dossier path plus a gist, which you read on demand. Where the facts the verdict depends on are already located, confirm them with bounded reads of the authoritative source instead of dispatching scouts; unscoped or noisy grounding still dispatches. A claim made in the conversation is a pointer to check, never self-verifying. The prior-decision scan (`<root>/solutions/`, ADRs, design docs) stays mandatory on either path.

When the judgment requires an explanation of unresolved behavior or design rationale, invoke `ce-explain`. Pass the question, its scope, and the decision it informs. Use adequate current evidence instead of repeating an investigation. Treat its cited findings as evidence to assess under the same grounding standard, not as authority for the recommendation. Keep ownership of the judgment here. If `ce-explain` is unavailable, gather the evidence directly or report what is missing.

### Phase 2: Verify Grounding

**Read `references/method.md` now**, before reasoning about the POV. It defines the Verify and POV steps, the skeptic stance, tiering, and the evidence check. Apply that check over the grounded evidence. If the evidence falls short, no subject shape may return a confident result; that reference names the result each shape returns instead.

### Phase 3: Point of View

First form ce-pov's own independent POV under the active subject-shape contract in `references/method.md`, but do not emit it. Freeze that position. Keep it out of an independent peer's initial context; expose it only when the task is to critique that position, or in a later reconciliation round.

A panel request is an explicit ask to consult or reconcile other models: a panel, a cross-check, or `oracle`, anywhere in the invocation context. Declining one, or merely mentioning one, is not a request. When a panel is requested, or when a POV formed without one may qualify for a proactive offer, read `references/cross-model-panel.md` before resolving participation or deciding whether to offer. Finish the panel branch before composing the result. A POV that follows a panel request states which peers ran, or that none did and why. A POV with no panel request carries no panel note.

Only then deliver the position with the content required by `references/method.md`. Adapt its presentation to the intended use; cite supporting evidence rather than reprinting dossiers or raw peer output.

### Phase 4: Deliver and return

The judgment is the deliverable; implementation is not. A calling workflow receives the result and control back. For a requested write-up or continuation, read `references/followup.md`; it defines artifact delivery and what authority a downstream action needs. Do not require a next-step choice to complete a POV.

© EveryInc · MIT · EveryInc/compound-engineering-plugin

See also

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor