rewrite-specs

Rewrites design docs and specs into present-tense end-state language in an isolated git worktree branch with atomic commit and classification trailer.

Updated May 7, 2026
One-click install
npx skills add https://github.com/marktoda/cohesive --skill rewrite-specs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rewrite-specs
Source: https://github.com/marktoda/cohesive/tree/main/skills/rewrite-specs
Command: npx skills add https://github.com/marktoda/cohesive --skill rewrite-specs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

After a design direction is approved via brainstorming, existing design docs, specs, and substrate artifacts often remain in future tense, contain obsolete claims, or contradict the new direction, leading to confusion during implementation and review and making it hard to track what actually changed.

Core Features & Use Cases

  • Hard rewrite of substrate artifacts: Rewrites all relevant design docs, specs, behavior matrices, named invariants, and gotchas to use present-tense end-state language, removing obsolete claims entirely instead of annotating them as deprecated.
  • Structured commit with classification: Classifies the rewrite as Pure implementation, Design, or Mixed, and commits all changes atomically to a dedicated design/<slug> branch with a mandatory classification trailer for downstream validation.
  • Isolated worktree operation: Runs all rewrites in an isolated git worktree to ensure changes can be reviewed as a coherent diff and discarded if needed without affecting the main codebase. Use case: For example, after your team approves a new architecture for the user authentication system, use this Skill to rewrite all related specs and docs to describe the new end state as if it is already implemented, giving the implementation team a single source of truth.

Quick Start

Use the rewrite-specs skill to hard-rewrite all design docs and specs for the approved new user authentication architecture to present-tense end-state language, and commit the changes to a dedicated design branch for fresh-eyes review.

Frequently Asked Questions about rewrite-specs

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I rewrite design documentation to reflect an approved architecture?

Rewriting design documentation to reflect an approved architecture involves hard-rewriting specs, behavior matrices, and named invariants into present-tense end-state language. This removes obsolete claims entirely, ensuring the implementation team has a single authoritative source of truth.

What is the best way to update obsolete specifications after a design brainstorm?

Updating obsolete specifications after a design brainstorm requires an explicit approved direction input to hard-rewrite existing docs. This process codifies the new architecture into authoritative substrate, removing contradictions and future-tense claims before implementation begins.

Can I isolate design spec rewrites in a git worktree?

Yes, you can isolate design spec rewrites in a git worktree to ensure changes are reviewed as a coherent diff. This operates exclusively on a dedicated design branch, allowing changes to be discarded without affecting the main codebase if needed.

How do I commit rewritten specs for downstream validation review?

To commit rewritten specs for downstream validation, you produce an atomic commit on a dedicated design branch with a mandatory Classification trailer. This trailer categorizes the rewrite as Pure implementation, Design, or Mixed for the review process.

Does rewriting design docs remove deprecated claims or keep them as annotations?

Rewriting design docs removes obsolete claims entirely instead of annotating them as deprecated. This hard-rewrite approach ensures all behavior matrices and named invariants use present-tense end-state language, preventing confusion during implementation.

When do I need to codify an approved feature direction into authoritative substrate?

You need to codify an approved feature direction into authoritative substrate during post-brainstorm workflows. When a refactor or architecture direction is approved, rewriting specs into end-state docs prevents confusion and makes tracking changes easier.