update-specs

Update functional specification files in docs/specs by appending or flagging warnings.

1|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/Trecek/useful-claude-skills --skill update-specs-trecek
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: update-specs
Source: https://github.com/Trecek/useful-claude-skills/tree/main/.claude/skills/update-specs
Command: npx skills add https://github.com/Trecek/useful-claude-skills --skill update-specs-trecek

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Add or update functional specification documents that describe what the software must do. Specifications are implementation-agnostic requirements. From these documents alone, a team could recreate the software in any language or framework without access to the current codebase.

Core Features & Use Cases

  • Specification files live in a dedicated directory (e.g., docs/specs/). Each file covers a component or functional area. If the user specifies a component, only update that file. Otherwise update all spec files.
  • Append and update only. Never remove a specification. Specs are a living record.
  • No implementation details. No language, framework, library, file path, class name, function name, data structure, or internal architecture belongs in a spec. Describe observable behavior and contracts between components.
  • Each spec is one testable requirement. If you cannot verify whether the software satisfies a spec through its external behavior or documented contracts, it is too vague. If a spec uses 'and' to join two distinct behaviors, split it.

Quick Start

Place or update specification files under docs/specs/ to reflect observable software behavior and use the provided workflow to validate them.

Frequently Asked Questions about update-specs

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

FAQPage Schema
How do I keep functional specifications aligned with observable software behavior?

Maintaining functional specifications requires appending new testable requirements to spec files rather than removing old ones, ensuring living documents stay synced with software behavior without containing implementation details. You apply updates across all spec files or target a specific component.

What is the best way to structure functional specification documents for a software project?

Structuring functional specification documents involves placing each component's spec in a dedicated directory like docs/specs/. Each spec must describe one testable requirement focusing on observable behavior and contracts between components, strictly avoiding any implementation details like language, framework, or file paths.

Can I include framework names and data structures in my software requirements specifications?

Including framework names, data structures, or file paths in software requirements specifications is not allowed. Specifications must be implementation-agnostic, describing only observable behavior and contracts so a team could recreate the software in any language without accessing the current codebase.

How do I update specifications for a single component without affecting other spec files?

Updating specifications for a single component requires specifying the component name during the update process. Only the spec file corresponding to that specific component or functional area will be appended or updated, leaving all other specification files untouched.

Why should I never remove a requirement from a functional specification document?

Never removing a requirement from a functional specification document is required because specs act as a living record. Edits are limited to appending new behaviors or flagging warnings, ensuring the historical context of observed software behavior remains intact over time.

When do I need to split a functional specification into multiple requirements?

Splitting a functional specification into multiple requirements is necessary when a spec uses 'and' to join two distinct behaviors. Each spec must represent one testable requirement verifiable through external behavior, preventing vague or combined conditions from obscuring software contracts.