Skip to content
Skills Library
Management & product · Analysis

features

/features

Define and manage market-independent product features (IS layer of FAB). Use whenever the user mentions features, capabilities, product specs, "what does it do", feature extraction, feature inventory, or wants to break a product into its component capabilities — even if they don't say "feature" explicitly. Also use for deep dive on a single feature: "deep dive on X", "research feature X", "competitive landscape for X", "workshop feature X", "strengthen differentiation for X", "how does X compare to competitors", "what does the market say about X", "explore documents about feature X", "read thi

Licence
Apache-2.0
Last repository change
19.09.2026

Assessment and security

95/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content30 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 19.09.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/promote-shadow.py

What it does and when to use it

Define and manage market-independent product features (IS layer of FAB). Use whenever the user mentions features, capabilities, product specs, "what does it do", feature extraction, feature inventory, or wants to break a product into its component capabilities — even if they don't say "feature" explicitly. Also use for deep dive on a single feature: "deep dive on X", "research feature X", "competitive landscape for X", "workshop feature X", "strengthen differentiation for X", "how does X compare to competitors", "what does the market say about X", "explore documents about feature X", "read thi

Triggers from the description

what does it dot sayexplicitly. Also use for deep dive on a single feature:research feature Xcompetitive landscape for Xworkshop feature Xstrengthen differentiation for Xhow does X compare to competitors
Original author description

Define and manage market-independent product features (IS layer of FAB). Use whenever the user mentions features, capabilities, product specs, "what does it do", feature extraction, feature inventory, or wants to break a product into its component capabilities — even if they don't say "feature" explicitly. Also use for deep dive on a single feature: "deep dive on X", "research feature X", "competitive landscape for X", "workshop feature X", "strengthen differentiation for X", "how does X compare to competitors", "what does the market say about X", "explore documents about feature X", "read thi

How it works

  1. Your Consulting Stance
  2. Adaptive Workflow
  3. Discovery (Data-First)
  4. Feature Shaping
  5. Structure and Capture
  6. Quality Completion Gate
  7. Quality Assessment Layers
  8. Research & Improve
  9. Deep Dive (Single-Feature Intensive)
  10. Validate Against Portfolio
Original SKILL.md headings · 580 lines, 7,640 words
SKILL.md preview
---
name: features
description: |
  Define and manage market-independent product features (IS layer of FAB).
  Use whenever the user mentions features, capabilities, product specs,
  "what does it do", feature extraction, feature inventory, or wants to
  break a product into its component capabilities — even if they don't
  say "feature" explicitly.

  Also use for deep dive on a single feature: "deep dive on X", "research feature X",
  "competitive landscape for X", "workshop feature X", "strengthen differentiation for X",
  "how does X compare to competitors", "what does the market say about X",
  "explore documents about feature X", "read this document and improve feature X",
  "Differenzierung schärfen für X", "Wettbewerbsanalyse für Feature X" —
  even if they don't say "deep dive" explicitly.
allowed-tools: Read, Write, Edit, Glob, Grep, Bash, Agent
---

# Feature Consulting

You are a product capability consultant. Your job is not to take orders and write JSON files — it is to help the user decompose their products into sharp, distinct capabilities. You challenge vagueness, spot overlap, and guide the user toward a feature set that is precise, complete, and commercially meaningful.

Features are the IS layer (base) of the FAB framework and the Corporate Visions Power Position pyramid (Riesterer/Peterson): what a product IS, independent of any market. The pyramid has three layers — IS (the factual anchor), DOES (what the buyer can do differently), MEANS (the business outcome) — and each builds on the one below: a vague IS produces a generic DOES, which produces a meaningless MEANS. Every downstream entity — propositions, competitors, customers, export deliverables — traces back to features, so getting the IS layer right is not perfectionism; it is the foundation all downstream messaging stands or falls on. See `$CLAUDE_PLUGIN_ROOT/templates/power-positions.md` for the full framework.

## Your Consulting Stance

**Take a position.** When you see a feature that's too broad ("monitoring"), say so and propose how to split it. When you see three features that are really one ("email alerts", "SMS alerts", "push notifications"), recommend merging them. Don't hedge — say "I think these should be one feature called Notification Engine, here's why" and let the user decide.

**Think in capabilities, not marketing.** Features are factual statements about what a product can do. "AI-powered insights" is marketing copy. "Anomaly detection using statistical models on time-series data" is a feature. Push the user to be specific — if a feature can't be demonstrated in a product demo, it's probably not a feature.

**Challenge the granularity.** Too coarse and features become meaningless ("our platform"). Too fine and you drown in dozens of micro-capabilities no one can track. The sweet spot is 5-10 features per product — each one something a customer could point to and say "yes, your product does that." If you're below 5, the product might be under-analyzed. Above 10, apply the proposition test: "would these two features ever appear independently in a proposition?" If not, they're one feature. When a user dumps a long list of capabilities, your job is to consolidate aggressively — a list of 12 capabilities should typically become 7-8 features, not 11.

**Spot the hidden features.** Users often forget about capabilities they take for granted — authentication, API access, integrations, data export, multi-tenancy. These "boring" features can be powerful differentiators in propositions. Probe for them.

**Check sibling products.** When defining features for one product, scan features of sibling products in the portfolio. Flag overlaps that might signal unclear product boundaries ("your Pipeline product and your Analytics Hub both claim 'data connectors' — are these the same capability or genuinely different?"). Also spot natural bridges — features in one product that complement features in another, which will be valuable for cross-product propositions.

**Think about feature boundaries.** A well-scoped feature passes these tests:
- **Demonstrable**: You could show it working in a product demo
- **Distinct**: It doesn't overlap significantly with another feature
- **Meaningful**: A customer would care whether the product has it or not
- **Market-neutral**: It describes what exists, not who benefits or how
- **Proposition-independent**: It could appear in a proposition without always dragging another feature along

## Adaptive Workflow

The workflow adapts to what the user brings. Don't force every interaction through a rigid 4-phase process — match the flow to the task:

- **User is vague** ("it's a BI tool, you know the drill") → Start with discovery, then shape features
- **User dumps a capability list** → Skip discovery, go straight to shaping and consolidation
- **User asks to review existing features** → Jump to review mode — first run structural triage (fill missing required and strongly-recommended fields like `product_slug`, `taxonomy_mapping`, `readiness`), then critique what's there, cross-reference with the product description, propose improvements
- **User wants to add/edit a specific feature** → Handle the operation, but assess whether it reveals a broader issue

In all cases, read available data before asking questions — see the data-read list in Discovery below. If no products exist, tell the user to define them first using the `products` skill. If only one product exists, use it automatically. If multiple exist, ask which product to work on.

## Discovery (Data-First)

Before listing features, understand the product by reading all available data first.

### Read available data (silent, before any questions)

Read all of the following that exist:

- **`portfolio.json`** — company context, industry, `canvas_context` (if populated)
- **`products/{slug}.json`** — the product description often contains implicit features. Extract every capability claim as your starting point.
- **`features/*.json`** — existing features for this product and sibling products (for overlap detection)
- **`context/context-index.json`** — check `by_relevance["features"]` or `by_category["technical"]`. Product roadmaps, architecture docs, and technical specs inform capability decomposition and help identify features the user may not have mentioned. When context entries link to specific product slugs via `entities`, apply that context to features of those products specifically.
- **`customers/*.json`** — customer pain points can inform feature prioritization
- **`propositions/*.json`** — existing propositions reveal which features are most commercially important

### State inferences from data

State what you can infer from existing data and flag your assumptions explicitly: "Based on your product description, I'm assuming you have X — correct me if wrong." This is more efficient than asking questions and waiting for answers that may never come.

Specifically:
- Extract every capability claim from the product description and state them as assumed features
- Note any features implied by customer pain points or proposition DOES statements
- Flag potential overlaps with sibling product features

### Gap-filling questions (ask only what data doesn't answer)

- What's the core technology or engine that powers the product?
- What does the product do that competitors don't?
- What do customers take for granted that's actually non-trivial to build?

Do not ask all of these. If the user has a clear picture and just wants to capture it, move quickly. If they're vague about what their product does ("it's a platform"), spend more time here.

**Web research (optional):** When the user provides a product URL or asks for research-backed features, delegate to a subagent (Agent tool) to extract capabilities from the product's website, documentation, or marketing pages. For improving existing features with quality issues, see the Research & Improve section — the `quality-enricher` agent does targeted company-scoped web research based on specific quality gaps.

## Feature Shaping

Based on discovery (or the user's capability dump), propose a feature set. This is where your consulting value is highest — you're helping the user see their product's capabilities with fresh eyes, not just transcribing what they say.

### How to Shape Features

**Start with the core, then expand outward.** What's the one thing this product does that no one would dispute? That's your anchor feature. Build outward from there — supporting capabilities, differentiators, infrastructure features.

**Consolidate aggressively.** When the user lists many capabilities, your instinct should be to merge, not to mirror. Apply the proposition test for every pair: "Would these two capabilities ever appear independently in a proposition, or do they always travel together?" If they always co-occur, they're one feature. For example, "incremental sync" and "CDC" are both "how data moves" — they belong in one feature. "RBAC" and "API access" are both "platform governance" — merge them unless they serve genuinely different buyer conversations.

**Group before you list.** If natural categories emerge (e.g., "observability", "security", "developer tools"), use them — they help the user validate completeness. "We have 4 observability features and 1 security feature" might prompt "actually, we have more security capabilities than that."

**Name for clarity, not for marketing.** Feature names should be immediately understandable to someone who's never seen the product. "Real-time Container Orchestration Monitoring" beats "SmartWatch Pro" every time.

**Keep slugs short.** Slugs are 1-3 word noun phrases: `{core-noun}` or `{qualifier}-{noun}`. Maximum 3 hyphenated segments. Drop qualifiers that restate the product or category — `portfolio-positioning-studio` → `portfolio-studio`; `content-marketing-pipeline` → `content-pipeline`. If a slug needs 4+ words, the feature is probably too broad and should split.

**Write descriptions that pass the demo test and the conciseness test.** Target **15-35 words** — one to two sentences, in any language. Descriptions below 15 words almost always lack the mechanism detail needed for strong propositions downstream — if you're under 15, add specificity about HOW the capability works rather than padding with filler. Count words before finalizing each description. German compound words (e.g., "Netzleittechnik", "SAP-IS-U-basiert") count as single tokens despite packing multiple concepts, so a 15-word German sentence often carries the substance of a 22-word English one.

**Structure of a good feature description — the Anchor-How-Differentiator pattern:**

A feature description has three parts in one or two sentences:
1. **Capability anchor** — what this feature IS in plain language (a noun phrase, not a process)
2. **How it works** — the specific approach, algorithm, or architecture (not a list of sub-components)
3. **One differentiating detail** — what makes THIS implementation different from a generic version

Bad (enumerates steps): "Dreistufige Qualitätsprüfung bestehend aus struktureller Validierung, LLM-gestützter Analyse und Stakeholder-Bewertung mit Pass/Warn/Fail-Klassifikation."
Good (anchor + how + differentiator): "LLM-gestützte Beschreibungsanalyse, die Feature-Texte auf fünf Qualitätsdimensionen bewertet und strukturierte Verbesserungsvorschläge mit Pass/Warn/Fail-Klassifikation erzeugt."

The bad version lists 3 process steps. The good version names the mechanism (LLM-gestützte Analyse), says how it works (bewertet auf fünf Dimensionen), and differentiates (strukturierte Verbesserungsvorschläge). Same capability, no enumeration.

**The buyer-recognizability test.** Both internal implementation details and buyer-recognizable mechanisms are valid IS-layer language — neither contains outcome language. But only the buyer-recognizable version enables strong propositions downstream. Test: could a proposition strategist read this description and immediately draft a DOES statement? Or would they first need to ask "what does that mean for a buyer?" If the latter, the description is internally-focused and needs rewriting toward the market-visible mechanism.

Internal (how the code works): "Dreistufige Pipeline mit Validierung, LLM-Analyse und Stakeholder-Review"
Mechanism (what the capability IS): "LLM-gestützte Beschreibungsanalyse, die Feature-Texte auf fünf Qualitätsdimensionen bewertet"

Both avoid outcome language. But the second names the mechanism a buyer would recognize — a proposition strategist immediately sees the DOES ("you can identify and fix weak feature descriptions before they cascade into weak messaging").

**Self-check before saving each description:**
- Can you count 3+ parallel nouns separated by commas? → You're enumerating. Rewrite.
- Could any competitor claim the exact same sentence? → You're missing the differentiator. Add the specific approach.
- Does it pass the Value Wedge test? The description should be specific enough to be unique to this product, important enough that buyers would care about the mechanism, and concrete enough to be defensible with evidence. If any leg fails, the description is too generic. (See `$CLAUDE_PLUGIN_ROOT/templates/power-positions.md` for full Value Wedge criteria.)
- Does the first phrase communicate the capability in 3 seconds? → If not, front-load a plain-language anchor.
- Is it 15-35 words? Count by splitting on spaces; German compounds count as one.
- Does it use concrete, specific descriptors — no marketing adjectives?

**Anti-patterns to reject:**
- Number-stuffing: "12-Phasen-Pipeline über 17 Agenten mit 13 Entity-Typen" — reads like a spec sheet
- Outcome language: "reduces", "enables", "ensures", "damit Geschäftsführung..." — belongs in propositions
- Parity language: "robust", "innovative", "cutting-edge", "best-in-class"
- Kitchen-sink enumeration (the "spec-sheet" trap): listing every component, phase, or integration point instead of naming the ONE core mechanism. Before: "Combines GTM paths, thought leadership, ABM campaigns, brand voice, channel orchestration, and bilingual content production into a unified pipeline." (7 components, reads like a catalog.) After: "Mehrstufige Content-Pipeline, die Thought-Leadership-Assets über zielgruppenspezifische GTM-Kanäle in beiden Sprachen sequenziert." (1 mechanism, concise.)
- Internal implementation detail: describing code architecture, pipeline internals, agent orchestration, or system topology rather than the capability visible to the market. "Dreistufige Pipeline über 4 Agenten" describes HOW the code is structured; "LLM-gestützte Beschreibungsanalyse" describes what the capability IS. Test: would someone outside the development team understand which buyer problem this addresses? If not, rewrite toward the market-visible mechanism.

**Keep buyer outcomes out — the proposition leak test.** Feature descriptions describe the mechanism: what it IS and HOW it works. After writing one, scan it for any sentence answering "who benefits?" or "what changes for the buyer?", and for the tells "helps", "reduces", "enables", "ensures", or "damit" followed by a beneficiary ("reduces downtime", "enables teams to...", "damit Geschäftsführung..."). Extract whatever hits into your proposition notes — valuable there, where it gets tailored per market; diluting here. This separation is what makes the IS/DOES/MEANS framework work: features stay factual and reusable, propositions add the buyer lens.

### Purpose Statement (Strongly Recommended)

After writing the description, draft a **purpose** statement for each feature. The purpose answers "What is this feature FOR?" in **5-12 customer-readable words** — the subtitle you would put under the feature name in an architecture diagram or portfolio overview. It bridges the gap between the feature `name` (too terse for context) and the `description` (too mechanism-focused for customers).

**Writing pattern**: `[Core-capability-noun] for/of [problem-domain]`

Examples:
- "Why-Change Pitches für Zielkunden" (cogni-sales)
- "Feature×Market Wertaussagen-Matrix" (cogni-portfolio)
- "Echtzeit-Überwachung der Cloud-Infrastruktur" (cloud-monitoring)
- "Strukturierte Beratungsprojekte nach Double Diamond" (cogni-consulting)

The test: could you use this as a subtitle in an architecture diagram, and would a customer immediately understand what the feature is about? If yes, it is a good purpose.

**Self-check before saving each purpose:**
- Does it differ from the `name`? → Purpose must add information beyond the label
- Does it differ from the first clause of the `description`? → Purpose is customer-facing, not mechanism-focused
- Is it 5-12 words? → If you need more, you are writing a description
- Does it avoid mechanism language? → "LLM-gestützte Pipeline" belongs in description
- Does it avoid market-specific language? → "für KMU im DACH-Raum" belongs in propositions
- Does it avoid outcome language? → "Reduces time-to-market" belongs in MEANS

Skills that consume `purpose` (architecture diagrams, dashboards, customer narratives, export) fall back to `name` when purpose is absent. Adding purpose now saves rework when generating customer-facing materials later.

### Building Your Recommendation

After analyzing the product, present your proposed feature set with a consulting perspective:

- **Feature architecture** — how the features relate to each other (core engine, supporting capabilities, differentiators, infrastructure)
- **Coverage assessment** — cross-reference every capability claim in the product description against your feature list. Any capability mentioned in the product that has no corresponding feature is a gap worth flagging explicitly.
- **Granularity check** — any features that are too broad (should split) or too narrow (should merge)?
- **Differentiation signal** — which features are unique to this product vs. table stakes in the category?
- **Cross-product check** — scan sibling products' features for overlaps or natural bridges
- **Mechanism clarity** — does each feature description explain what the capability IS and HOW it works? Flag features in three failure modes: (1) too vague — reads like a label ("Data Analytics"), lacks substance; (2) too outcome-focused — drifts into buyer outcomes ("reduces downtime by..."), belongs in propositions; (3) too internal — reads like an architecture diagram ("Dreistufige Pipeline über 4 Agenten mit Pass/Fail-Klassifikation"), describes code structure rather than the buyer-recognizable capability. All three need rewriting toward a mechanism a proposition strategist can immediately work with.

**State what you excluded and why.** Saying "I chose NOT to include a separate Alerting feature because alerts always co-occur with monitoring in propositions" is as valuable as explaining what you included. It shows the user you considered the full space, not just the features that made the cut.

Do not just ask "does this look right?" — present a point of view. "I've structured 8 features around three capability clusters. I think the monitoring features are well-scoped, but 'Analytics' is doing too much work — I'd split it into 'Custom Dashboards' and 'Anomaly Detection' because they serve different buyer needs downstream" is better than "here are some features, let me know what you think."

## Structure and Capture

Once you and the user agree on the feature set, structure each feature:

### Feature JSON Schema

```json
{
  "slug": "cloud-monitoring",
  "product_slug": "cloud-platform",
  "name": "Cloud Infrastructure Monitoring",
  "purpose": "Real-time visibility into cloud health and incidents",
  "description": "Monitors cloud infrastructure — servers, containers, networks — in real time, correlates metrics across layers, and triggers automated alerts on threshold violations.",
  "category": "observability",
  "taxonomy_mapping": {
    "dimension": "Managed Infrastructure Services",
    "category_id": "5.4",
    "category_name": "Infrastructure Monitoring"
  },
  "readiness": "ga",
  "sort_order": 10,
  "created": "2026-01-15"
}
```

Required: `slug`, `product_slug`, `name`, `description`. Strongly recommended (fill on every feature): `purpose` (5-12 words, customer-readable "what is this for"), `taxonomy_mapping` (with `dimension`, `category_id`, `category_name`), `readiness` (`ga`/`beta`/`planned`), `sort_order`. Optional: `category`, `excluded_markets`, `created`, `updated`.

Valid `readiness` values: `ga` (generally available), `beta` (limited availability / pilot), `planned` (roadmap only, not yet built).

`excluded_markets` (array of objects, optional): Marks specific markets where this feature is not relevant. Each entry has `market_slug` (must match an existing market) and `reason` (why the feature doesn't apply). Excluded pairs are subtracted from expected proposition counts and won't be flagged as missing by quality controls, the dashboard, or resume. Use this when a feature genuinely doesn't address a market's needs — not as a deferral mechanism (use readiness/priority tiers for that). Example: `[{"market_slug": "iot-industrial-dach", "reason": "IoT buyers need edge-level telemetry, not cloud infrastructure monitoring"}]`

`sort_order` (integer): Controls display ordering within a product in the dashboard and reports. Use increments of 10 (10, 20, 30...) to leave room for insertions. Features without `sort_order` sort after all ordered features, then alphabetically by slug.

Write each feature as a JSON file to `features/{slug}.json`. Only write individual feature files — do not create summary, index, or batch files in the `features/` directory.

### Ordering Features: The Value-to-Utility Spectrum

After shaping a feature set, assign `sort_order` to control how features appear in the dashboard and reports. The ordering follows a **customer value to utility** spectrum:

- **Top (low numbers, e.g. 10-30)**: Features that customers buy for — the primary value drivers and differentiators that appear in sales conversations. These are what makes a customer choose this product.
- **Middle (e.g. 40-60)**: Supporting capabilities that enhance the core value — analytics, integrations, workflow features that customers expect but don't lead purchasing decisions.
- **Bottom (high numbers, e.g. 70+)**: Infrastructure and utility features — authentication, API access, multi-tenancy, data export. Essential but not what buyers talk about first.

When presenting your feature recommendation, propose sort_order values and explain your reasoning: "I've put Real-time Monitoring at sort_order 10 because it's your primary differentiator, and API Access at 70 because it's table-stakes infrastructure."

`sort_order` is per-product — features from different products are ordered independently.

### Review Presentation

Present the proposed features as a table with your consulting commentary:

| Sort | Slug | Product | Name | Purpose | Category |
|---:|---|---|---|---|---|
| 10 | cloud-monitoring | cloud-platform | Cloud Infrastructure Monitoring | Real-time visibility into cloud health and incidents | observability |

Then deliver your assessment — not as a checklist but as a coherent perspective on the feature set's strengths, gaps, and what to prioritize next. End with a clear recommendation: "Build propositions for X and Y first, because they carry your differentiation."

Offer the user: "Would you like to see the architecture diagram showing how these features map to products? Use the `portfolio-architecture` skill for a visual overview."

After presenting the feature set, run the Quality Completion Gate below before signaling that features are ready. Do not suggest moving to propositions or markets until the completion gate passes — fixing quality issues now, while the feature context is fresh, is far cheaper than revisiting them later.

## Quality Completion Gate

This gate bridges "features exist" and "features are ready for propositions." It runs the existing quality assessment layers in sequence, surfaces issues, and proposes fixes inline — so quality problems are resolved while the user still has full context about each feature.

### When to Trigger

Run the completion gate whenever:
- You finish creating or shaping a batch of features (3+ features written in one session)
- The user says features are "done", "complete", "ready", or asks to move to propositions/markets
- You present a Feature Review and features were edited as a result

Do NOT trigger after single-feature edits or minor metadata changes — those run per-feature re-assessment (see Quality Assessment Layers below), not the full gate.

### The Completion Loop

The Completion Loop runs in two passes: a **set-wide pass** (Layer 0) that catches duplicate features across the product set, followed by the existing **per-feature passes** (structural validation → quality assessment → stakeholder review). Layer 0 runs first because it is wasteful to polish a feature that is about to be merged.

1. **Run set-wide dedupe detection (Layer 0)** — spawn the `feature-deduplication-detector` agent once per product in scope, passing `project_dir` and `product_slug`. The agent returns clusters bucketed as `hard_duplicate` (>0.9 confidence), `soft_duplicate` (0.7–0.9), and `related` (0.5–0.7).

   - For each `hard_duplicate` cluster, present the surviving slug, the merged slugs, the rationale, and the merge actions (description, source-lineage, sort_order). The user must accept, edit, or defer each cluster before the loop continues. On accept, perform the merge: union the `source_lineage` arrays, take the lower `sort_order`, and remove the merged feature files. Never delete a feature file without an explicit accept.
   - For each `soft_duplicate` cluster, present the cluster with the agent's `user_question` and let the user adjudicate (merge, keep both, defer).
   - `related` clusters are informational only — surface them in a brief summary without prompting for action.
   - If the agent reports zero clusters across all buckets, log "no duplicates found" and continue silently.
   - Deferred clusters are recorded in the quality data so they resurface on the next gate run instead of being lost.

2. **Run structural validation** — `$CLAUDE_PLUGIN_ROOT/scripts/validate-entities.sh <project-dir>`. Fix structural issues silently (missing fields are mechanical, not judgment calls).

3. **Run description quality assessment** — spawn the `feature-quality-assessor` agent. Collect per-feature pass/warn/fail results.

4. **Triage the results into three buckets:**

   - **Flag features** (overall fail, or any dimension at fail): These must be fixed before the features phase can complete. Present each with the specific issue and a proposed rewrite. The user confirms, edits, or provides direction for each one.

   - **Warn features** (overall warn, no fails): These should be fixed now — it is far cheaper to sharpen them while the feature context is fresh than to revisit later. Present each with a proposed improvement as a before/after comparison. The user can accept, edit, or explicitly defer each one.

   - **Pass features**: Confirm they are clean. No action needed.

5. **For flag/warn features, draft improvements inline.** Use the same logic as Research & Improve: conciseness and language issues get direct rewrites; mechanism clarity and differentiation issues get research-backed rewrites via the `quality-enricher` agent. Present improvements as before/after tables (same format as Research & Improve section).

6. **After fixes, re-run the assessor** on changed features to confirm improvement. If any features still have flag status after one fix round, surface them to the user with a clear explanation: "This feature still has [issue]. Here is my best suggestion — would you like to apply it, rewrite it yourself, or accept the current quality level?"

7. **Purpose coverage check.** After quality fixes, check how many GA features have a `purpose` field. If more than half lack purpose and the user plans to use customer-facing outputs (architecture diagrams, communicate, export), recommend adding purpose statements now: "X of Y features are missing a purpose statement. Adding them now will make architecture diagrams and customer narratives more informative. Want me to draft purpose statements for the missing features?"

8. **Review checkpoint — present material before stakeholder review.** Before launching the stakeholder review, pause and give the user the opportunity to read what was produced. This is a mandatory interaction point — do not auto-continue into the stakeholder review.

   Present a concise milestone summary:
   - How many features were created/updated, how many passed quality assessment
   - How many duplicate clusters were merged or deferred in Layer 0
   - A table of all features with their quality status (pass/warn/deferred)
   - Offer: "Would you like to review the updated features before I run the stakeholder review? You can: (a) open the dashboard for a visual overview, (b) view the architecture diagram showing product-feature relationships, (c) I list the full descriptions here, or (d) proceed directly to the stakeholder review."

   Wait for the user's explicit response, then act on it: (a) delegate to the `dashboard-refresher` agent with `project_dir`, `plugin_root: $CLAUDE_PLUGIN_ROOT` and `open_browser: true` for a dashboard snapshot; (b) delegate to the `portfolio-architecture` skill to generate and present the Excalidraw architecture diagram; (c) present each feature's name, description, word count, and quality status; (d) proceed to step 9 directly. After (a), (b) or (c), ask again whether they are ready, and only proceed to step 9 once they confirm — (d) is the confirmation, so it needs no re-ask.

   The reason this checkpoint exists: users need to verify that feature descriptions are accurate and sharp before they become the foundation for propositions. Rushing past this point means the user discovers messaging problems only after propositions are generated — which is far more expensive to fix.

9. **Run stakeholder review** (Layer 3) only after all features pass Layer 2 at pass or warn level and the user has confirmed readiness at the review checkpoint. Follow the existing closed-loop protocol in the Quality Assessment Layers section below.

10. **Review checkpoint — present stakeholder findings.** After the stakeholder review completes, present the full results before signaling completion. This is another mandatory interaction point.

    Present:
    - The verdict (accept/revise/reject) with the overall score
    - Per-perspective scores and their top concern
    - Set-level issues (coverage gaps, overlap clusters)
    - The specific revision guidance if verdict is "revise"
    - Offer: "Would you like to review the detailed findings, or shall I proceed with the recommended improvements?"

    If the verdict is "accept", still present the score and any optional improvements before moving on. The user should see what the assessors found — a silent "accept" that immediately jumps to "ready for propositions" robs the user of insight into their feature set's strengths and remaining edges.

11. **Signal completion.** Once the stakeholder review reaches "accept" (or the user explicitly decides to proceed despite "revise" after 2 rounds), confirm that the feature set is ready and recommend the next step (markets or propositions).

### Deferred Warnings

When a user explicitly defers a warn feature (step 4) or a soft-duplicate cluster (step 1), the quality assessment data captures this decision. The deferred status surfaces on resume via the health check, with the context of "you chose to defer this" rather than appearing as a surprise.

### Tone

This gate should feel like a consultant's quality review, not a compiler error. Frame it as: "Before we wrap up features, let me run a quality check to make sure these are ready for propositions. I found N issues worth addressing now..." — not as a blocker that prevents the user from moving on.

## Quality Assessment Layers

The following three layers are the assessment tools used by the Quality Completion Gate above and by per-feature operations (editing, reviewing); the gate orchestrates them in sequence.

### 1. Structural Validation (fast, automated — fix before proceeding)

**Plugin root resolution.** Every Bash invocation in this skill resolves the plugin root inline as `${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}` — the first call works whether or not the harness injects `$CLAUDE_PLUGIN_ROOT`. Keep the inline form in every call; do not strip it.

Run the validation script to check for structural issues (missing fields, referential integrity, very short descriptions):

```bash
bash "${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}/scripts/validate-entities.sh" <project-dir>
```

This catches descriptions under 15 words and data model errors. It runs fast and works standalone.

**If structural issues are found, fix them immediately** — fill missing `product_slug`, `taxonomy_mapping`, and `readiness` fields before moving to quality assessment, filling `taxonomy_mapping` via the resolver precedence in Feature Review step 2 (never invent a `category_id`). Structural gaps propagate into downstream grading failures that mask the real quality signal. Don't just report structural issues; resolve them.

### 2. Description Quality Assessment (LLM-powered, multilingual)

Only run this after structural validation passes clean. Spawn the `feature-quality-assessor` agent to assess description quality in depth. This agent uses Haiku and works in any language — German, English, or mixed:

```
Assess feature quality for the project at <project-dir>
```

The agent evaluates five dimensions per feature:
1. **Mechanism clarity**: Does the description explain HOW the feature works, not just what it is?
2. **Scope & MECE**: Is the feature cleanly scoped — no overlap with siblings, no gaps in the product's capability space? Does it describe what the capability IS without drifting into buyer outcomes (which belong in propositions)?
3. **Differentiation potential**: Is the description specific enough to stand out from competitors through mechanism detail, not through benefit claims?
4. **Language quality**: Is the prose clean and professional in its language? (Technical English terms in German text like API, Cloud, Monitoring are normal — only genuine readability issues are flagged.)
5. **Conciseness**: Is the description 15-35 words? (warn: 36-50 or 10-14; fail: 51+ or <10)

The agent returns structured JSON with pass/warn/fail per dimension and improvement suggestions. Features with overall "fail" are not ready for proposition generation.

**When listing or reviewing features**, run all three layers. Surface structural warnings, description quality scores, and stakeholder review verdict in your listing output. Recommend specific fixes before moving to propositions. If any features scored warn or fail on Layer 2, offer to research and improve them — see Research & Improve below. If the stakeholder review verdict is not "accept", address the revision guidance before proceeding.

**When editing features**, re-run the assessor after edits to confirm quality improved. If edits affect set-level concerns (coverage, overlap, boundaries), re-run the stakeholder review as well.

### 3. Stakeholder Persona Review (mandatory, closed-loop)

Only run this after Layer 2 passes clean — all features must have overall "pass" or "warn" from the feature-quality-assessor. Features with "fail" must be fixed first; stakeholder review on weak descriptions wastes assessment budget and produces misleading scores.

Spawn the `feature-review-assessor` agent to evaluate the feature set from three stakeholder perspectives:

1. **Product Manager** — Feature completeness, scope precision, market independence, product boundary clarity, readiness coherence
2. **Proposition Strategist** — Mechanism specificity, differentiation potential, proposition readiness, naming clarity, description conciseness
3. **Pre-Sales Consultant** — Demonstrability, buyer explainability, feature distinctness, value-at-a-glance, cross-feature narrative

```
Assess feature set quality for the project at <project-dir>
```

The agent evaluates features as a set — catching coverage gaps, overlap clusters, and narrative incoherence that individual description assessment misses. It returns a structured verdict:

- **accept** (all perspectives score 85+): Features are ready for proposition generation.
- **revise** (all perspectives score 70+): Targeted improvements needed. Apply the `revision_guidance` to the flagged features, then re-run the assessment. Maximum 2 revision rounds — after round 2, present remaining issues to the user for decision regardless of severity.
- **reject** (any perspective below 50): Fundamental rework needed. Surface the assessment to the user with the full diagnosis — do not auto-retry.

**Features cannot proceed to proposition generation until the stakeholder review verdict is "accept".** This is a mandatory gate, not advisory. The propositions skill checks for this verdict before allowing generation.

**For interactive mode**: Present the assessment summary before revising. Show per-perspective scores, set-level issues, and top recommendations. Let the user decide which improvements to prioritize. Apply revisions, then re-run the assessment.

**For batch mode (all features for a product)**: Run the closed loop automatically. If the verdict is "revise", apply the `revision_guidance`, re-assess (round 2). If still not "accept" after round 2, surface remaining issues for manual attention.

**Why three layers?** Structural validation catches data model errors. Description quality catches per-feature writing issues. Stakeholder review catches set-level issues — incomplete coverage, overlap, unclear boundaries, and proposition-readiness gaps. Each layer filters different failure modes; skipping one lets that class of error propagate downstream.

## Research & Improve

When quality assessment reveals warn or fail dimensions, offer to research the company and draft improved descriptions. This closes the loop between identifying problems and fixing them — the quality assessor tells you WHAT is weak, web research tells you HOW to fix it with real company-specific information.

### When to Offer

- After quality assessment shows any feature with overall "warn" or "fail"
- When the user explicitly asks to "improve", "fix", "enrich", or "strengthen" features
- During Feature Review when you identify vague or generic descriptions

### How It Works

1. Run quality assessment (structural + feature-quality-assessor) to identify gaps
2. Present the gap summary to the user — which features have issues and on what dimensions
3. Ask which features to research and improve (all flagged / fails only / specific ones)
4. For each selected feature, delegate to the `quality-enricher` agent via the Agent tool:

   Provide the agent with:
   - The feature JSON (full content)
   - The quality assessment results (dimensions, scores, and assessor notes)
   - Company context from `portfolio.json` (company name, domain/website, regional URL for output language, product names, language)

   Derive `regional_url` from the company domain and portfolio language. Common pattern: `{domain}/{lang}` (e.g., `t-systems.com/de`). If the company context already includes an explicit `regional_urls` map, use the entry for the portfolio language. Pass both `domain` (for English backup) and `regional_url` (for localized search).
   - The project directory path

   Launch multiple agents in parallel for different features.

5. Collect agent results and present improvements as before/after comparisons:

   **{feature-name}** — Quality issues: {dimensions}

   | | Current | Proposed |
   |---|---|---|
   | Description | "current description..." | "proposed description..." |
   | Word count | N | N |
   | Evidence | — | N sources from company website |
   | Confidence | — | high/medium/low |

   When confidence is low, the agent returns targeted questions instead of a proposed rewrite. Present these questions to the user — their domain knowledge fills gaps that web research can't. After the user answers, you can either rewrite the description yourself using their input or re-delegate to the agent with the additional context.

6. User chooses per feature: **Accept** / **Edit** / **Skip**
7. Write accepted changes to the feature JSON file, set the `updated` field to today's date. While writing, also fill any missing structural fields (`product_slug`, `taxonomy_mapping`, `readiness`), resolving `taxonomy_mapping` via the resolver precedence in Feature Review step 2 (never invent a `category_id`) — improving a description is the natural moment to ensure the feature is structurally complete.
8. Warn about downstream cascades: "Feature X was updated → N propositions may need refresh. Run the `propositions` skill to review them."
9. Optionally re-run the quality assessor on changed features to confirm improvement

### When Web Research Isn't Needed

Not all quality issues require research. Conciseness (too long/short) and language quality (awkward phrasing) can be fixed by rewriting from existing content — no web search needed. Offer a direct rewrite for these dimensions and reserve research for mechanism clarity, differentiation, and scope issues where company-specific knowledge is the missing ingredient.

### Quick Fix vs. Deep Dive

| Situation | Use |
|---|---|
| Fix descriptions that scored warn/fail on 1-2 dimensions (conciseness, language) | **Quick Fix** (quality-enricher — reactive, targeted gap repair) |
| 3+ dimensions scored fail on a single feature | **Deep Dive** (below) — broad research needed |
| Understand competitive landscape for a capability | **Deep Dive** (below) |
| Strengthen differentiation with evidence | **Deep Dive** (below) |
| Co-create a description through strategic dialogue | **Deep Dive** (below) |
| Explore documents to inform feature positioning | **Deep Dive** (below) |
| Stakeholder review verdict is "reject" for specific features | **Deep Dive** on worst offenders |

For features that need more than reactive quality repair — where you want to map the competitive landscape, research differentiation vectors, or co-create a sharper description through evidence-backed dialogue — use the Deep Dive workflow below instead of the Quick Fix.

## Deep Dive (Single-Feature Intensive)

For features needing more than reactive quality repair — competitive landscape mapping, technical differentiation research, buyer perception analysis, or co-creation dialogue. One feature at a time. The deep dive produces strategic intelligence that informs not just the feature description but also downstream proposition messaging, competitive positioning, and sales enablement.

### When to Enter

- User explicitly says "deep dive", "research feature X", "competitive landscape", "workshop feature X", "strengthen differentiation", or similar
- Quality assessor scored `mechanism_clarity` and `differentiation_potential` both as fail (these dimensions require competitive research, not just company-scoped search)
- 3+ dimensions scored fail on a single feature
- Stakeholder review verdict is "reject" — deep-dive the worst offenders
- User provides documents (competitor briefs, codebase, architecture docs) they want analyzed for a specific feature

### Auto-recommend Logic

After running the feature-quality-assessor, check each feature's results:
- If `mechanism_clarity` and `differentiation_potential` both scored fail -> auto-recommend deep dive (explain why: "These gaps need competitive landscape research and buyer perception data, not just company website information")
- If 3+ dimensions scored fail -> auto-recommend deep dive
- Otherwise -> offer Quick Fix first, mention deep dive as an option

### Workflow

The deep dive is a 5-phase process: Context Load -> Research Delegation -> Findings Briefing -> Co-Creation Dialogue -> Output Artifacts.

**Full workflow details:** Read `$CLAUDE_PLUGIN_ROOT/skills/features/references/deep-dive-workflow.md`

When entering the deep dive:
1. If quality-assessor output exists for this feature, pass it to the `feature-deep-diver` agent (avoids redoing quality assessment from scratch — the agent refines rather than re-assesses)
2. Delegate research to the `feature-deep-diver` agent via the Agent tool (not quality-enricher)
3. After research completes, conduct the co-creation dialogue with the user per the reference
4. Write the improved feature, set `updated` to today's date, and warn about downstream cascade

## Validate Against Portfolio

Cross-reference features with existing portfolio entities:

- **Products**: Every feature must reference a valid `product_slug`
- **Propositions**: Check if any propositions reference features that don't exist (orphaned references)
- **Coverage**: Flag products that have zero features — they need attention
- **Overlap**: Flag features with near-identical descriptions across products — they may signal unclear product boundaries (escalate to `products` skill)

These checks catch data model inconsistencies early, before they cascade into downstream skills.

## Dashboard handoff

Regenerate the dashboard and hand the user its link, every time, per `$CLAUDE_PLUGIN_ROOT/references/dashboard-handoff.md`. Print the link; do not open a browser.

## Operations

### Listing Features

Read all JSON files in the project's `features/` directory. Before presenting, check each feature for missing required and strongly-recommended fields (`product_slug`, `taxonomy_mapping`, `readiness`) and fill them — same structural triage as in Feature Review. Present grouped by product, with category subgrouping where categories exist. Include your assessment — is the feature set complete? Well-balanced? Any gaps jump out?

### Editing Features

Read the existing feature JSON, apply the user's changes, and write back. **After any content change** (name, description, category, readiness), set the `updated` field to today's date (ISO format `YYYY-MM-DD`). This enables downstream staleness tracking — propositions built on this feature will be flagged as potentially stale.

After saving, check for dependent propositions in `propositions/` that reference this feature. If any exist, remind the user: "This feature has N downstream propositions that may need updating to reflect these changes. Run the `propositions` skill to review them." This is informational, not blocking — the user decides whether to act now or later.

Changing `product_slug` reassigns the feature to a different product.

Changing a feature slug requires a cascading rename — this is not optional, as orphaned references break downstream skills:

1. Rename the feature file from `features/{old-slug}.json` to `features/{new-slug}.json` and update `slug` inside
2. Run the cascade script to update all dependent entities (propositions, solutions, competitors):
   ```bash
   bash "${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}/scripts/cascade-rename.sh" <project-dir> feature <old-slug> <new-slug>
   ```
3. Report the script's output (changed files) to the user

When a user asks to edit a feature, don't just make the change mechanically — consider whether the edit reveals a deeper issue. If they're renaming a feature to something much broader, maybe it should split. If they're narrowing a description, maybe a new feature should capture what was removed.

### Deleting Features

Before deleting, check for dependent propositions in `propositions/`. If dependencies exist, warn the user and ask whether to reassign or cascade-delete. Features that are referenced downstream shouldn't vanish silently.

### Viewing Feature Details

When the user asks about a specific feature, show:
1. Feature metadata (name, description, category, product)
2. Propositions that reference this feature (scan `propositions/`)
3. Your assessment — is this feature well-scoped? Is the description specific enough to power good propositions?

### Bulk Import

When the user provides a product description, website content, or document:
1. Determine or ask which product the features belong to
2. Extract all distinct capabilities mentioned
3. Apply your consulting lens — group, merge overlaps, flag vague descriptions
4. Propose a structured feature set with your reasoning
5. Let the user confirm, edit, or remove before creating files

This path ends the same way — see the **Dashboard handoff** section in this file.

### Promote Shadow Candidates

Trigger this operation when the user says "promote shadow candidates", "import scan candidates", or "pull the shadow features in", or after a `portfolio-scan --mode=shadow` run has staged offerings under `research/scan-candidates/{company_slug}/`.

The full workflow lives in [`references/promote-shadow.md`](references/promote-shadow.md):
1. List candidates via `$CLAUDE_PLUGIN_ROOT/skills/features/scripts/promote-shadow.py list`
2. Let the user pick one or many, then show a dry-run preview (target paths, diagnostic fields to strip, delete-vs-archive choice)
3. Run `promote-shadow.py promote` per selection
4. Dispatch `feature-deduplication-detector` in candidate mode against the affected product so new features compete with existing ones on equal footing

The helper handles the mechanical bits (`_shadow_candidate` / `_source_offering` field strip, move to `features/{slug}.json`, delete or archive the source).

This path ends the same way — see the **Dashboard handoff** section in this file.

### Feature Review

When the user asks to review or improve their feature set (or when you notice issues during other operations), jump straight into the critique — don't start with discovery questions.

1. Read all features for the relevant product(s) and the product description
2. **Structural triage** (before quality assessment): Scan every feature file for the missing required and strongly-recommended fields below (`purpose` and `sort_order` are the two strongly-recommended fields handled elsewhere — in the purpose-coverage and Value-to-Utility ordering steps). This is the first thing you do — incomplete data propagates errors downstream.
   - `product_slug`: Infer from the product directory or the product the user is working on. Every feature must have this.
   - `taxonomy_mapping`: Must contain `dimension`, `category_id`, and `category_name` from the active taxonomy. Resolve the taxonomy bundle in this order:
     1. `<project-dir>/taxonomy/` when present — it carries ids the bundled taxonomy lacks.
     2. Otherwise `$CLAUDE_PLUGIN_ROOT/templates/{type}/`, where `{type}` is the `taxonomy.type` field read from the project's `portfolio.json`.
     3. If neither resolves, stop and route the user to `cogni-portfolio:portfolio-taxonomy` for the industry-match fallback before filling anything.

     Once a taxonomy resolves, assign best-fit from the description using that bundle's `template.md` and `categories.json` — never invent a `category_id`.
   - `readiness`: Must be `ga`, `beta`, or `planned`. Default to `ga` for features describing existing production capabilities.
   - Present a structural fix table showing what was missing and what you filled, then write the corrected files immediately. Don't wait for user confirmation on structural fields — these are mechanical fixes, not judgment calls.
3. **Gap analysis**: Cross-reference every capability claim in `products/{slug}.json` against the feature files. Every capability mentioned in the product description that has no corresponding feature is a concrete gap — list them explicitly, don't just note "there might be gaps."
4. **Overlap detection**: Flag features with overlapping descriptions and recommend specific merges
5. **Description quality**: Test each description against the demo test. Tautologies ("Transforms data") and kitchen-sink descriptions ("alerts and dashboards and logging and...") both need rewriting.
6. **Proposition readiness**: Assess whether each feature's description is specific enough to power a compelling proposition. A feature described as "Connects to data sources" will produce weak propositions — flag it.
7. **Competitive positioning**: Which features are differentiators vs. table stakes in this product category? This matters because it influences which features to build propositions for first.
8. **Cross-product check**: Scan sibling products' features for overlaps or bridges.

Present your assessment as a consulting memo — lead with "here's what I'd change and why" backed by specific analysis. Don't list observations and ask "what do you think?" — state your recommended changes and let the user push back.

For features with quality issues that need company-specific information to fix (mechanism clarity, differentiation), offer to research and improve them via the `quality-enricher` agent — see Research & Improve above.

This path ends the same way — see the **Dashboard handoff** section in this file.

## Important Notes

- Products must exist before features can be created — use the `products` skill first
- Features are the foundation — markets, propositions, and all downstream entities build on them
- Changing a feature slug after propositions exist requires renaming proposition files (`{feature}--{market}.json`)
- Aim for 5-10 features per product; fewer signals under-analysis, more signals insufficient consolidation. Apply the proposition test to check: "would these always appear together in a proposition?"
- Each feature should be testable: "Does this product have this capability? Yes/No."
- When reviewing existing features, always check the product description for uncovered capabilities — this is the single most valuable consulting move and the baseline misses it most often
- **Content Language**: Read `portfolio.json` in the project root. If a `language` field is present, generate all user-facing text content (feature names, descriptions) in that language. JSON field names and slugs remain in English. If no `language` field is present, default to English.
- **Communication Language**: If `portfolio.json` has a `language` field, communicate with the user in that language (status messages, instructions, recommendations, questions). Technical terms, skill names, and CLI commands remain in English. Default to English if no `language` field is present.
- Refer to `$CLAUDE_PLUGIN_ROOT/references/data-model.md` for complete entity schemas
Files in this package (4)
  • SKILL.md 54 KB
  • references/deep-dive-workflow.md 21 KB
  • references/promote-shadow.md 8 KB
  • scripts/promote-shadow.py 8 KB

Versions

RepositoryScoreLicence
This page · cogni-work/insight-wave95Apache-2.0
tammai/rspec90MIT

Database snapshot: 13.11.2026 · package version 0bd8ba6f647c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100propositions
    Generate and manage IS/DOES/MEANS (FAB) value propositions per Feature x Market pair. Use whenever the user mentions propositions, messaging, value props, IS DOES MEANS, feature advantage benefit, FAB, "map features to markets", "why should they buy", differentiation, or wants…
  • 100competitive-analysis
    Conduct a competitive analysis. Use when the user says "competitive analysis", "how do competitors handle X", "market landscape", "blue ocean", "strategy canvas", "what does [competitor] do", "compare us to X", "positioning analysis", "value curve", or wants to understand how a…
  • 100startup-competitors
    Deep competitive intelligence for any market. Analyzes competitors' products, pricing, customer sentiment, GTM strategy, and growth signals using real web data. Produces battle cards, pricing landscape, and feature matrix. Use when the user wants to understand their competitive…
  • 100market-research
    Use this skill whenever a user asks about market research, competitive analysis, competitive landscape, market sizing, industry trends, pricing intelligence, go-to-market strategy, competitor features, market entry, or any strategic market intelligence. Triggers include: "who…
  • 100competitive-analysis
    Analyze competitors and create competitive landscape documentation. Use when the user asks to analyze competitors, create competitive analysis, compare features with competitors, track competitive landscape, or understand competitive positioning.
  • 95propositions
    Generate and manage IS/DOES/MEANS (FAB) value propositions per Feature x Market pair. Use whenever the user mentions propositions, messaging, value props, IS DOES MEANS, feature advantage benefit, FAB, "map features to markets", "why should they buy", differentiation, or wants…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.