Skip to main content
skill CX Codex

feature-manifest — Claude Code skill for feature manifests and traceability

A skill for working with feature manifests: create them, check health, map features to code, update changelogs. Useful when you need to know which code belongs to which feature.

MIT 181 installs ★ 274 updated 2026-10-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill feature-manifest -a claude-code
Open on GitHub

What feature-manifest does

This skill handles a feature manifest system — YAML files that record which implementation files, tests, dependencies and environment variables belong to each feature. It can create a new manifest, validate it, find orphaned files and stale entries, update history and changelog.

It runs through npm scripts: npm run feature:info, npm run feature:validate, npm run feature:health, npm run feature:create. A health check mode reports healthy features, stale ones, features without tests, and files in src/ that no manifest tracks.

A manifest holds the feature status (planned, in-progress, complete, deprecated), implementation files, entry point, database tables, API routes, tests, internal and external dependencies, environment variables, history and changelog. The skill needs npm and npx access — without Node.js in the project the commands will not run.

One limit to keep in mind: it is not for project management, issue tracking or git workflow. Only code-to-feature traceability.

What it helps with

  • find which feature owns a specific file
  • detect files in src/ not tracked by any manifest
  • check if a manifest went stale after code changes
  • create a manifest for a new feature with implementation, tests, dependencies
  • update the changelog and history before committing

Example prompts for the agent

  • Create a manifest for a new feature my-feature named "My Feature".
  • Show which files belong to the auth feature.
  • Run a health check on all manifests and find orphaned files.

How to install feature-manifest

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill feature-manifest -a claude-code

2Manually: put the files in place

~/.claude/skills/feature-manifest/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/feature-manifest/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about feature-manifest

How do I install feature-manifest in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill feature-manifest -a claude-code. The skill lands in ~/.claude/skills/feature-manifest/SKILL.md.

What does feature-manifest do?

It manages feature manifests for code traceability: creates features, validates manifest health, maps features to code, updates changelogs. It is not for project management, issue tracking or git workflow.

What do I need to run it?

Node.js and npm in the project, because the skill runs npm scripts: npm run feature:info, npm run feature:validate, npm run feature:health, npm run feature:create.

Source text

SKILL.md · MIT
---
name: feature-manifest
description: Manage feature manifests for code traceability — create features, validate manifest health, map features to code, update changelogs. Activates for 'feature manifest', 'feature tracking', 'code
  traceability'. NOT for project management, issue tracking, or git workflow.
allowed-tools: Read,Write,Edit,Bash(npm:*,npx:*)
metadata:
  category: Productivity & Meta
  tags:
  - feature-management
  - code-traceability
  - documentation
  pairs-with:
  - skill: git-workflow-expert
    reason: Feature branches map to manifest entries for tracking code-to-feature traceability
  - skill: technical-writer
    reason: Feature manifest documentation feeds into changelogs and release notes
  - skill: launch-readiness-auditor
    reason: Feature manifests provide the checklist for launch readiness feature completeness
---

# Feature Manifest Management

This skill helps you work with the feature manifest system that tracks the relationship between features and their implementations.

## When to Use This Skill

- Creating a new feature
- Modifying existing feature code
- Checking which feature owns a file
- Validating manifest accuracy
- Updating changelogs
- Running feature health checks

## Quick Commands

```bash
# List all features
npm run feature:info -- --list

# Get details about a feature
npm run feature:info -- <feature-id>

# Find which feature owns a file
npm run feature:info -- --files <filepath>

# Validate all manifests
npm run feature:validate

# Check feature health (staleness, orphans, coverage)
npm run feature:health

# Create a new feature manifest
npm run feature:create
```

## Workflow: Creating a New Feature

1. **Create the manifest first:**
   ```bash
   npm run feature:create -- --id=my-feature --name="My Feature"
   ```

2. **Implement the feature**, adding files as you go

3. **Update the manifest** with:
   - All implementation files in `implementation.files`
   - Tests in `tests.unit/integration/e2e`
   - Dependencies in `dependencies.internal/external`
   - Environment variables in `dependencies.env_vars`

4. **Validate before committing:**
   ```bash
   npm run feature:validate
   ```

## Workflow: Modifying an Existing Feature

1. **Read the manifest first:**
   ```bash
   npm run feature:info -- &lt;feature-id>
   ```

2. **Make your changes** to the implementation files

3. **Update the manifest:**
   - Add new files to `implementation.files`
   - Update `history.last_modified` to today's date
   - Add a changelog entry

4. **Validate:**
   ```bash
   npm run feature:validate
   ```

## Manifest Structure

```yaml
id: feature-id
name: Human Readable Name
status: complete  # planned | in-progress | complete | deprecated
priority: P1

description: |
  What this feature does and why it exists.

implementation:
  files:
    - src/app/api/feature/route.ts
    - src/lib/feature.ts
  entry_point: src/lib/feature.ts
  database_tables:
    - tableName
  api_routes:
    - POST /api/feature

tests:
  unit:
    - src/lib/__tests__/feature.test.ts
  integration: []
  e2e: []

dependencies:
  internal:
    - features/authentication.yaml
  external:
    - package-name
  env_vars:
    - FEATURE_SECRET
  secrets:
    - feature-api-key

history:
  created: "2024-12-01"
  last_modified: "2024-12-23"

changelog:
  - version: "1.0.0"
    date: "2024-12-23"
    changes:
      - "Initial implementation"
```

## Health Report Interpretation

When running `npm run feature:health`:

- **Healthy Features**: Manifest matches code, tests exist
- **Stale Features**: Manifest not updated in 90+ days, or code changed after manifest
- **Without Tests**: Complete features that have no tests listed
- **Orphaned Files**: Files in `src/` not tracked by any manifest
- **Suggested Manifests**: New directories that should have manifests

## Best Practices

1. **One feature per manifest** - Keep them focused
2. **Update on every change** - Don't let manifests go stale
3. **Changelog is append-only** - Never modify old entries
4. **Include all files** - Don't leave orphaned files
5. **Link dependencies** - Show which features depend on others

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Agent setup: memory, context, orchestration →
Manifest Generator daffy0208 Manifest Generator turns a skill or MCP description into a YAML capability manifest: preconditions, effects, domains, risk. Useful when the descriptions exist but the orchestration cards do not. CX Codex +1 131installs edit-manifest chrono-meta edit-manifest — a Claude Code skill that closes the edit loop in a harness: every change to SKILL.md, rules, or CLAUDE.md gets stored with a predicted effect, and the next session checks the prediction against what actually happened. CX Codex +1 ★ 33repo stars platform-manifest-generate forcedotcom platform-manifest-generate writes a Salesforce package.xml or a destructive manifest from a source folder, a component list, or org introspection. Handy when the deploy is ready but the manifest is not. CX Codex +1 3,300installs manifest-yaml-cursorrules-prompt-file PatrickJS manifest-yaml-cursorrules-prompt-file — a Cursor rule that turns the assistant into a Manifest backend developer. It kicks in when generating demo apps with entities and relationships in YAML. CX Codex +1 ★ 41,178repo stars generate-ppmplugin-manifest Microsoft generate-ppmplugin-manifest is a Claude Code skill that validates and stages manifest.json for .ppmplugin bundles before packaging, checking names, prefixes, and entrypoints without build tools. CX Codex +1 ★ 1,167repo stars pcf-manifest-schema official github pcf-manifest-schema — a rule that feeds Copilot the structure of ControlManifest.Input.xml: which elements and attributes exist and what they do. Useful when editing a PCF component manifest. CX Codex +1 ★ 41,430repo stars

From the same set180

The whole set →
knot-theory-educator knot-theory-educator visualizes braid theory and topological concepts using step-wise animations and explainer cards. CX Codex +1 182installs senior-coding-interview senior-coding-interview — a skill for L6+ coding interview practice: build small systems, explain trade-offs, and handle follow-up changes during live coding. CX Codex +1 181installs web-weather-creator web-weather-creator builds stylized weather effects like clouds, waves, and mist with SVG filters and CSS animations. Keeps production interfaces expressive without loading WebGL libraries. CX Codex +1 181installs design-trend-analyzer The design-trend-analyzer skill picks design directions, color palettes, and type systems for a project. Use it when you need to compare visual approaches and turn one into specs. CX Codex +1 181installs design-justice design-justice guides digital equity and trauma-informed UX for public benefits, legal aid, and services used on shared devices or unstable connections. CX Codex +1 181installs liaison liaison turns multi-agent activity into status briefs, decision requests, and progress reports. Use it when project activity is hard to follow. CX Codex +1 181installs terraform-iac-expert terraform-iac-expert — a Claude Code skill for infrastructure as code: modules, state, multi-environment layouts, backends, secrets. Useful when a Terraform project outgrows a single main.tf. CX Codex +1 179installs swift-executor swift-executor pushes coding tasks past blockers and toward a working result. Use it for urgent fixes, prototypes, and work stuck in planning. CX Codex +1 179installs

Project sponsors

Companies that keep this analytics open