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

ce-strategy — Claude Code skill for product strategy

This skill creates or updates a project-root STRATEGY.md covering the product, its users, metrics, and areas of focus. Use it when starting a product or changing direction.

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

What ce-strategy does

ce-strategy guides an interview to draft STRATEGY.md, then presents the full draft for review before writing it. For an existing file, it checks the document's shape and preserves it when the file was created in another format or shared with other authors.

The skill uses repository documents and recent activity to ask sharper questions, not to infer strategy from the code. It keeps strategy focused on what the product is and why; feature ideas, prioritization, and implementation plans belong elsewhere. Before editing an existing file, it requires reading references/update-run.md.

Check document ownership first: the skill does not edit author-approved sections or documents the user does not own. The available skill text is truncated, so details of the later update flow are not covered here.

What it helps with

  • draft a STRATEGY.md for a new product
  • define product positioning and intended users
  • record key metrics and where they live
  • revisit strategy after a change in direction
  • update a section while preserving the document's structure

Example prompts for the agent

  • Interview me and draft a `STRATEGY.md` for this project.
  • Review the `metrics` section in `STRATEGY.md` and show your draft before writing.
  • Check whether the `tracks` section is stale and suggest an update.

How to install ce-strategy

1Skills CLI (Vercel)

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

2Manually: put the files in place

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

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

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

why cursor The skill investigates why code took its current shape by checking Git history and available MCP sources, then returns cited findings about decisions and tradeoffs. Claude Code CX Codex Cursor +1 5,700installs hyperplan code-yeongyu A team of five agents with opposing roles stress-tests a plan. Only what survives the crossfire makes it to the final scheme. Claude Code CX Codex Cursor +1 576installs ctf-web ljagiello Routes and guides agents through web CTF challenges, covering everything from SQL injection and SSTI to auth bypasses and SSRF. Claude Code CX Codex Cursor +1 9,700installs hindsight-local vectorize-io This skill stores preferences, task learnings, and procedure outcomes, then retrieves relevant context before new work begins. Claude Code CX Codex Cursor +1 493installs swiftui-performance-audit official OpenAI Pinpoints SwiftUI runtime issues like frame drops, unresponsive taps, and excessive view body computations. Works code-first and guides Instruments profiling. CX Codex GP ChatGPT 109installs react-expert reactjs Researches React APIs and internals directly against tests, commits, and pull requests. Useful for writing accurate docs without relying on outdated model memory. Claude Code CX Codex Cursor +1 1,300installs find-skills vercel-labs Discovers and installs agent skills from skills.sh directly inside your coding assistant. Handy when you need domain-specific workflows for a project. Claude Code CX Codex Cursor +1 4,000,000installs frontend-design official anthropics This skill guides intentional visual design for new interfaces and redesigns. Use it when a generic generated UI is not enough. Claude Code Claude.ai 1,025,790installs

Questions about ce-strategy

How do I install ce-strategy in Claude Code?

Run npx skills add EveryInc/compound-engineering-plugin --skill ce-strategy -a claude-code. The same command is listed as the next installation step.

What does ce-strategy do?

It interviews the user about the product and drafts or updates the repository-root STRATEGY.md. The user reviews the draft before it is written.

How does ce-strategy handle an existing strategy document?

It reads references/update-run.md before making changes. It preserves the shape of documents created in another format or shared with other authors, and leaves author-approved sections untouched.

Source text

SKILL.md · MIT
---
name: ce-strategy
description: "Create or update STRATEGY.md. Use when starting a product, adding a strategy doc, or changing direction or roadmap."
argument-hint: "[optional: section to revisit, e.g. 'metrics' or 'approach']"
---

# Product Strategy

**The current year is 2026** - use it when dating the document.

`ce-strategy` writes and maintains its part of `STRATEGY.md` - the repo-root project document that captures what the project is, who it serves, how it succeeds, and where the team is investing. The file is shared with other tools and people; this skill writes only the sections `references/strategy-template.md` names. Downstream skills read it when it exists: `ce-ideate`, `ce-brainstorm`, and `ce-plan` for what work is on-strategy; `ce-product-pulse` for the product name and key metrics; `ce-dogfood` for the primary persona. Its frontmatter keys and this skill's section headings are the contract those skills parse - keep them for every section this skill authors; a meaning an existing section already carries is merged into it (`references/update-run.md`).

**Done:** `STRATEGY.md` exists at the repo root and the user has seen what will be written and had an edit pass. For a file in this skill's house format, every required section is filled from answers that survived pushback (or explicitly deferred to a linked legacy doc) and the file matches `references/strategy-template.md`. For a file in any other shape, done is the user-approved minimal edits applied, with the document's shape unchanged. A section the user could not sharpen in two rounds is written as given and named in chat as worth revisiting - a completed run, not a blocked one.

## Boundaries

- **Anchor, not plan.** Strategy is what the product is and why. Features belong in `ce-brainstorm`, schedules and prioritization in the issue tracker, implementation plans in `ce-plan`; do not let them creep into the doc, and do not update the tracker or reconcile in-flight work.
- **The user answers; the repo only grounds the question.** Use evidence to ask a sharper question, never to fill in a section. Do not derive the strategy from the repo.
- **Short is a feature.** Push back on expansion rather than adding sections.
- **Record which metrics matter and where they live**, not what they read today.
- **Meaning is the contract; the shape belongs to whoever created the doc.** A file that is solely this skill's (`references/update-run.md` states the test) is maintained in house format on every write: headings renamed, sections in the template's current order, missing required sections offered. Do not treat it as multi-writer merely because the file is shared in principle. A file in any other shape, hand-written or from another tool, is read by meaning and edited in its own shape and idiom: no restructuring into the template, no uninvited frontmatter or headings. Either way, two things are never edited: a section carrying an author-approved marker (e.g. `<!-- <tool>: author-approved 2026-07-10 -->`), and a doc the user does not own. For those, report the conflict, or write a separate file that links to it. A targeted update preserves every other section's content exactly. Where that section sits follows the same ownership test: a solely-owned file takes the template's order; a multi-writer file is never reordered. `references/update-run.md` defines the rest and is a required read before you edit an existing file.

## Asking and routing

Ask one question at a time through the host's blocking question tool already in the current tool list. Match by capability; never probe a user-facing tool to discover it. Fall back to numbered options on the visible chat surface only when no such tool is listed or a real question call errors. Never silently skip the question.

Any argument this skill was invoked with — present in the current prompt or conversation, from the user or a calling skill — is a focus hint: a section to revisit (`metrics`, `positioning`, `tracks`; older names such as `approach` or `who it's for` map to the current section) or a scope hint. With none, proceed open-ended and let the file state decide the path.

## Phase 0: Ground and route

Phase 0 produces a repo model and a decision about which phase runs next, whatever the harness reads. `references/grounding.md` is a non-optional load: it carries the full source list and the wording of the disagreement question and the focus hint.

**The repo model** is your working understanding of what this product is. Read `STRATEGY.md` if it exists. Take what the product is from its stated intent and structure - README, `CONCEPTS.md`, `docs/`, sibling docs such as `PRODUCT.md`, what the code is organized around - and bound that read to "what is this and who is it for" rather than profiling the whole repo. Take what is getting attention now from recent commits or PRs. Attention informs only the Tracks question and staleness in an update run; where it disagrees with stated intent, that is a question for the user, never a conclusion. Show the model in chat before the first question: three to five lines on what you take the product to be, who it seems to serve, and where attention has gone, each with its source named, and invite correction. If the model did not supply the product's name, ask for it here - the template's frontmatter and title need it. A repo with no substantive content is a normal path: say so in one line and run the interview ungrounded.

**The next phase** is announced in one line by file state: no file -> Phase 1 ("Strategy doc not found - let's write it."), after the legacy-sibling offer in `references/grounding.md` when one applies; file exists -> Phase 2 ("Found existing strategy - let's review and update.").

## Phase 1: First-run interview

Read `references/interview.md` before the first question - a non-optional load. The opening questions, pushback rules, anti-pattern examples, quality bar, blocking-question tool per host, and the two-round cap live there; improvising from memory produces a passive transcription instead of a strategy doc.

Run the interview in this order (the document itself follows the template's order; Boundaries is asked after the stress test, where its content comes from):

1. Purpose
2. Positioning
3. Users
4. Key metrics
5. Tracks
6. Stress test
7. Boundaries (always written)
8. Milestones (optional)
9. Brand (optional)

When every section is captured, read `references/strategy-template.md`, fill it in, present the full draft in chat, offer one round of edits, then write `STRATEGY.md`.

## Phase 2: Update run

Read `references/update-run.md` first - a non-optional load, before the summary, the drift check, or any question. It decides how drift candidates are raised, which section is revisited, and what is preserved untouched. An update run summarizes the file's current state in 3-5 lines, and names any section the repo model suggests is stale as a candidate rather than a verdict. It then revisits the section the focus hint named, or the one the user picks when asked. The user may pick any section; list the drift candidates first, as suggestions rather than as the only choices. Every other section's content is left untouched, and its place follows the ownership test in `references/update-run.md`. Questions and pushback still come from `references/interview.md`, applied as if this were a first run.

## Phase 3: Downstream handoff

Note in one line where the file lives and that `ce-ideate`, `ce-brainstorm`, and `ce-plan` pick it up as grounding on their next run. If no downstream skill has run here yet, suggest `ce-ideate` or `ce-brainstorm` as a next step.

© 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