dev-changelog

/​dev-changelog - Implementation Summary

Skill Awareness: See skills/​_registry.md for all available skills.

• Before: /​dev-review passes (code is good)
• Reads: Git changes, specs, use cases
• Outputs: Summary of what was built, what's left, docs to update

Capture what was implemented after review passes. Creates actionable documentation.

When to Use

• After /​dev-review passes
• End of sprint/​milestone
• Before handoff to another developer
• When you need to resume work later

Usage

/​dev-changelog billing              # Summarize billing feature work
/​dev-changelog --since=v1.0.0       # Changes since tag
/​dev-changelog --since=2024-01-01   # Changes since date
/​dev-changelog --pr=123             # Changes in specific PR

Output

plans/​features/​{feature}/
├── summary.md              # What was built (this session/​PR)
├── implementation.md       # Cumulative implementation status
├── tech-debt.md            # Known issues, TODOs
└── docs-updates.md         # Documentation tasks

Expected Outcome

Documentation of what was implemented after /​dev-review passes.

Outputs:

• summary.md - What was built this session/​PR
• implementation.md - Cumulative status (updated)
• tech-debt.md - Known issues, TODOs (updated)
• docs-updates.md - Documentation tasks

Success Criteria

• Changes mapped to specs and use cases
• Completion status clear (done/​partial/​not started)
• Tech debt captured (TODOs, workarounds, gaps)
• Documentation tasks identified
• Easy to resume work later
• Clear what's done, what's remaining

Prerequisite

Verify /​dev-review passed:

• If review not done or failed → "Run /​dev-review first"

Sources to Gather

Git (source of truth):

• git log --oneline {since} - Commits made
• git diff --stat {since} - Files changed
• gh pr view {number} - PR info (if available)

Intent & Context:

• specs/​*.md - What was intended
• use-cases/​*.md - Business context
• implementation.md (previous) - Track cumulative status

Analysis

Map git changes to specs and use cases:

For each changed file:

• What component? (API, UI, model, etc.)
• Which spec item does it fulfill?
• Which use case does it support?
• Complete or partial?

Extract tech debt:

• TODOs in changed files (grep for TODO/​FIXME/​HACK/​XXX)
• Incomplete spec items (spec says X, implementation does Y)
• Known issues from commits (WIP, temporary, workaround)
• Review comments not addressed

Identify doc updates needed:

Output Files

summary.md (per session/​PR):

• What was built (API, UI, data changes)
• Spec items completed (with status)
• Use cases addressed (coverage)
• Commits list
• Next steps

implementation.md (cumulative):

• Overall progress percentage
• Completed items (with PR reference)
• In progress items (what's done, what's remaining)
• Not started items (with blockers if any)
• History (date, PR, summary)

tech-debt.md (updated):

• High/​Medium/​Low priority issues
• Location, impact, notes for each
• Code TODOs with file:line references

docs-updates.md (updated):

• Required updates (API Reference, User Guide, Configuration)
• Examples to add (code snippets)
• Screenshots needed

Resume Flow

When returning to work later:

1. Read implementation.md → See what's done, what's remaining
2. Read tech-debt.md → See known issues
3. Read summary.md (latest) → See where you left off
4. Continue with /​dev-specs or /​dev-coding

Integration with /​dev-review

When /​dev-review completes successfully:

/​dev-review output:
├── quality-report.md (existing)
└── Suggests: "Run /​dev-changelog to document what was built"

Then:
/​dev-changelog
├── Reads review output
├── Reads git changes
├── Generates summary.md, implementation.md, etc.

Resume Flow

When returning to work later:

1. Read implementation.md
   → See what's done, what's remaining

2. Read tech-debt.md
   → See known issues

3. Read summary.md (latest)
   → See where you left off

4. Continue with /​dev-specs or /​dev-coding

Tools Used

Example Flow

User: /​dev-changelog billing

1. Verify review
   → Found: plans/​features/​billing/​review-report.md (passed)

2. Gather sources
   → Git: 5 commits since last changelog
   → Specs: SPEC-PAY-001 to 006
   → UCs: UC-PAY-001 to 005

3. Analyze changes
   → 3 API files changed
   → 4 UI files changed
   → 2 new models

4. Map to specs
   → SPEC-PAY-001: Complete (checkout)
   → SPEC-PAY-002: Complete (payments)
   → SPEC-PAY-004: Partial (subscriptions)

5. Extract tech debt
   → 3 TODOs found
   → 1 incomplete spec item

6. Identify doc updates
   → 3 new endpoints need docs
   → 2 new UI features need guide

7. Generate outputs
   → summary.md
   → implementation.md (updated)
   → tech-debt.md (updated)
   → docs-updates.md

Output:
"Documented billing implementation:
 - 2 specs complete, 1 partial
 - 3 tech debt items
 - 6 doc updates needed

 See: plans/​features/​billing/​summary.md"