Claude Cursor Skill

feature-radar

Full-cycle feature discovery, evaluation, and prioritization. Builds a persistent knowledge base at .feature-radar/ and runs a 6-phase workflow to recommend what to build next. Modes: full (all phases), quick (scan only), evaluate (prioritize), #N (deep-dive one). MUST use this s

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download runkids-my-skills-feature-radar_feature-radar-614b89f.zip · 10 KB

Install

skills CLI npx skills add https://github.com/runkids/my-skills/tree/main/feature-radar/feature-radar
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install runkids-my-skills@llmmart
Git git clone https://github.com/runkids/my-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole runkids/my-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Feature Discovery & Prioritization

Mode Routing

Files (my-skills)
  • references
    • DEEP-READ.md 1.3 KB
      Loading…
    • DIRECTIVES.md 1.7 KB
      Loading…
    • SPEC.md 9.9 KB
      Loading…
    • WORKFLOW-PATTERNS.md 805 B
      Loading…
  • SKILL.md 9 KB
    ---
    description: |-
      Full-cycle feature discovery, evaluation, and prioritization. Builds a persistent knowledge
      base at .feature-radar/ and runs a 6-phase workflow to recommend what to build next.
      Modes: full (all phases), quick (scan only), evaluate (prioritize), #N (deep-dive one).
      MUST use this skill whenever the user asks about feature priorities, roadmaps, what to build,
      or wants to evaluate/compare feature ideas — even if they don't say "feature radar" explicitly.
      Use when the user wants to decide what to build next, rank or compare features and backlog
      items, plan a roadmap or project direction, reassess deferred or open opportunities, or
      mentions the .feature-radar/ directory.
    metadata:
      targets:
        - claude
    name: feature-radar
    ---
    
    # Feature Discovery & Prioritization
    
    ## Mode Routing
    
    <HARD-GATE>
    Parse the user argument BEFORE any other logic. Determine the mode:
    
    | Argument | Mode | Phases |
    |----------|------|--------|
    | (none) or `full` | full | 1-6 (all) |
    | `quick` | quick | 1-3 only |
    | `evaluate` | evaluate | reconciliation → 5-6 (skip 1-3) |
    | `#N` (e.g. `#2`) | focus | Read opportunity N → Phase 5 (single item) → Phase 6 |
    
    Route rules:
    - **full**: Follow normal workflow (Phase 1-6).
    - **quick**: Execute Phase 1-3, then skip to Completion Summary.
    - **evaluate**: Run "Subsequent Runs" reconciliation (steps 1-2), then jump directly to Phase 5-6.
    - **focus (#N)**: Read `.feature-radar/opportunities/{N}-*.md`. If not found, list available opportunities and ask user to pick. Then run Phase 5 for that single opportunity, followed by Phase 6.
    
    State the detected mode before proceeding: "Mode: {mode}"
    </HARD-GATE>
    
    ## Bootstrap (First Run)
    
    If `.feature-radar/` does not exist at the project root, create it:
    
    ```
    .feature-radar/
    ├── base.md
    ├── archive/
    ├── opportunities/
    ├── specs/
    └── references/
    ```
    
    Then generate `base.md` by completing the following:
    
    <HARD-GATE>
    Complete ALL steps before presenting base.md to the user:
    
    1. **Detect stack and architecture** — start from `go.mod`, `package.json`, `Cargo.toml`, `pyproject.toml`, then the code they point to.
    2. **Map structure** — identify entry points, core logic, tests, docs, and configuration across the top-level directories.
    3. **Extract features** — from exports, commands, API routes, or public functions, described by what the implementation does.
    4. **Find inspiration sources** — read README, CONTRIBUTING, docs/ for related projects and communities
    5. **Verify with user** — present the generated base.md and ask: "Does this accurately describe your project?"
    </HARD-GATE>
    
    After presenting base.md, support iterative refinement per `references/WORKFLOW-PATTERNS.md`.
    
    <HARD-GATE>
    Do NOT proceed to the Workflow until the user approves base.md.
    </HARD-GATE>
    
    ### base.md Template
    
    Generate `base.md` following the structure defined in `references/SPEC.md` (sections 2-5).
    Read `references/SPEC.md` first, then fill `{placeholders}` with project-specific analysis.
    
    Key sections to generate:
    - **Project Context** — detected language, architecture, key feature areas, core philosophy, inspiration sources
    - **Feature Inventory** — implemented features table + value & innovation landscape table
    - **Tracking Summary** — counts per category (start at 0)
    - **Directory Layout** — tree view
    - **Classification Rules** — per references/SPEC.md §3.2-3.5
    - **Maintenance Workflow** — feature flow between directories
    - **Archive Extraction Checklist** — per references/SPEC.md §4.3
    
    After creating the directory, ask the user:
    **"Should I add `.feature-radar/` to `.gitignore`?"**
    (Recommended if the tracking data is internal and shouldn't be committed.)
    
    ## Subsequent Runs
    
    On subsequent runs (`.feature-radar/` already exists):
    1. Read existing `base.md` — do NOT overwrite
    2. Run reconciliation per `references/DEEP-READ.md` steps 2-6
    3. Proceed to Mode Routing
    
    ## Behavioral Directives
    
    <HARD-GATE>
    Read and follow `references/DIRECTIVES.md`.
    
    Additional directives for this skill:
    - **Do not skip phases outside mode rules** — follow the Mode Routing and Phase execution HARD-GATEs. For conditional phases, state the skip condition check result before deciding to skip.
    - **Reconcile on subsequent runs** — see "Subsequent Runs" section above.
    </HARD-GATE>
    
    ## Workflow
    
    Execute phases in order.
    
    <HARD-GATE>
    Phase execution rules (mode-dependent):
    
    **full mode** (default):
    - Phase 1-3: ALWAYS execute.
    - Phase 4: Skip ONLY if no documentation directory exists.
    - Phase 5-6: Skip ONLY if no open opportunities exist.
    
    **quick mode**:
    - Phase 1-3: Execute. Stop after Phase 3 → Completion Summary.
    
    **evaluate mode**:
    - Phase 1-4: Skip (reconciliation already done in Subsequent Runs).
    - Phase 5-6: Execute. Skip ONLY if no open opportunities exist.
    
    **focus mode (#N)**:
    - Phase 1-4: Skip.
    - Phase 5: Evaluate the single targeted opportunity only.
    - Phase 6: Propose for that opportunity only.
    </HARD-GATE>
    
    ### Phase 1: Scan & Classify
    
    1. Read source files (feature ideas, user feedback, ecosystem observations, creative proposals, issue trackers)
    2. Cross-reference each entry against the codebase
    3. Classify:
       - **Done / Covered / Rejected / N/A** → archive
       - **Open / Partially Done** → opportunity
       - **Cross-cutting pattern** → specs
       - **External observation** → references
    
    **Checkpoint**: Present classification results using this format, then ask "Continue to Phase 2?"
    
    ```
    Phase 1 complete:
    | Classification | Count | Items |
    |---------------|-------|-------|
    | Archive       | {n}   | {list} |
    | Opportunity   | {n}   | {list} |
    | Spec          | {n}   | {list} |
    | Reference     | {n}   | {list} |
    ```
    
    ### Phase 2: Archive Completed Features
    
    For each archive candidate:
    
    1. Create `archive/{nn}-{slug}.md`
    2. Run the **Archive Extraction Checklist** (mandatory):
       - Extract learnings → `specs/`
       - Derive new opportunities → `opportunities/`
       - Update references → `references/`
       - Update ecosystem trends → `specs/ecosystem-trends.md`
    3. Mark the entry as processed in the source (strikethrough + status)
    
    ### Phase 3: Organize Open Opportunities
    
    1. Create `opportunities/{nn}-{slug}.md`
    2. Assess **Impact** and **Effort** realistically
    3. Write an honest "Our Position" — do we actually want this?
    
    **Checkpoint**: Present opportunities using this format, then ask "Continue to Phase 4?"
    
    ```
    Phase 3 complete: {n} opportunities organized
    | # | Opportunity | Impact | Effort | Our Position |
    |---|------------|--------|--------|-------------|
    | {nn} | {title} | High/Med/Low | High/Med/Low | {1-line stance} |
    ```
    
    ### Phase 4: Gap Analysis
    
    Find implemented features that docs don't mention:
    
    1. Scan documentation for coverage of implemented features
    2. For each gap: which feature, which page should cover it, standalone guide or section
    
    ### Phase 5: Evaluate & Prioritize
    
    | Criterion | Question |
    |-----------|----------|
    | **Real user demand** | Are users actually asking for this? |
    | **Value uplift** | Does this meaningfully improve the user experience or unlock new possibilities? |
    | **Innovation potential** | Does this introduce a creative breakthrough or unique approach? |
    | **Effort / impact ratio** | Is the cost justified by the benefit? |
    | **Architectural fit** | Does it align with our core philosophy? |
    | **Ecosystem timing** | Is the ecosystem ready? |
    
    Rank into tiers:
    - **Build next**: High value + strong demand or innovation potential + reasonable effort
    - **Build soon**: Good value + moderate demand
    - **Monitor**: Low demand or premature
    - **Skip**: Conflicts with philosophy or negligible value
    
    **Checkpoint**: Present tier ranking using this format, then ask "Continue to Phase 6 (Propose)?"
    
    ```
    Phase 5 complete:
    | Tier | # | Opportunity | Demand | Value | Innovation | Effort/Impact | Fit | Timing |
    |------|---|------------|--------|-------|------------|--------------|-----|--------|
    | Build next | {nn} | {title} | {H/M/L} | {H/M/L} | {H/M/L} | {H/M/L} | {H/M/L} | {H/M/L} |
    | Build soon | ... | | | | | | |
    | Monitor    | ... | | | | | | |
    | Skip       | ... | | | | | | |
    ```
    
    ### Phase 6: Propose & Decide
    
    For each "Build next" feature (top 1-3), present a proposal card:
    
    ```
    ### {nn}. {Title}
    **Pitch**: {One paragraph — what value does this create?}
    **Effort**: {N days} — {brief justification}
    **Key decisions**:
    - {decision 1}
    - {decision 2}
    ```
    
    After all cards, ask: **"Should we enter plan mode for [feature]?"**
    
    ## Completion Summary
    
    Follow the template in `references/DIRECTIVES.md`, with skill name "Complete" and an additional line:
    `Top recommendation: {feature name} — {one-line pitch}`
    
    ## Guardrails
    
    - **Don't copy blindly.** Evaluate fit with YOUR architecture and users, not someone else's.
    - **Don't overcount.** 1 issue with no comments = weak signal.
    - **Don't undercount.** Multiple independent asks = strong signal.
    - **Chase value, not features.** Ask "what problem does this solve?" before "what does this do?"
    - **Be honest about effort.** Low < 1 day. Medium 1-3 days. High 1+ week.
    - **Challenge deferred items.** "Deferred" ≠ "forever" — re-evaluate each session.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.