specpilot archive

    1

    Automate requirement archiving and index updates for standardized project documentation.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    specpilot archive

    Example session with this skill installed

    /specpilot:archive REQ-042

    • Read your context and instructions
    • Compiled the specpilot archive

    Requirement REQ-042 has been archived.

    The index has been updated to mark this as completed, and the technical draft has been preserved for future reference.

    Archive Summary: REQ-042-auth-provider-refactor

    FieldValue
    IDREQ-042
    Status✅ completed
    Created2023-10-15
    Completed2023-11-20
    ModuleAuthentication

    Technical Scope

    FileChangeDescription
    src/auth/provider.tsModifiedRefactored context injection
    src/hooks/useUser.tsModifiedAdded memoization to profile fetch

    Implementation Logic

    The refactor moved the provider logic to a singleton pattern to prevent multiple re-renders during route transitions. We preserved the legacy interface for backward compatibility but added deprecation warnings.

    Retention Policy

    • Archive File: docs/specpilot/requirements/REQ-042-auth-provider-refactor.md
    • Full Draft: docs/specpilot/requirements/REQ-042-draft.md (Updated with completion status)
    • Index: docs/specpilot/requirements/index.md (Row updated)

    Next steps

    1. Review the generated archive for any missing implementation pitfalls.
    2. Commit the new documentation files to the repository.
    3. Start the next requirement from the prioritized backlog.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Software documentation often rots the moment a feature ships, leaving developers with zero context on past technical decisions. This skill automates the archiving of completed requirements, ensuring your project history remains searchable and structured without manual overhead. It transforms messy working drafts into clean, standardized archive files while maintaining the full technical context for future reference.

    What it does

    • Standardized archiving generates compact requirement records using a predefined template for quick lookups.
    • Index synchronization updates your central requirement registry to reflect completion status and timelines.
    • Version tracking handles iterative requirements by linking new work to legacy IDs and updating status flows.
    • Context preservation retains draft files and design documents as "technical bibles" rather than deleting them.
    • Automated metadata extracts key descriptors and timestamps to maintain a consistent naming convention.

    How it works

    1. Identify the requirement ID from user input or by scanning the in_progress list in the index file.
    2. Validate the existence of working drafts and associated technical design documents.
    3. Generate the finalized archive file using the REQ-000-template.md structure.
    4. Update the index.md status, adding completion dates and handling iteration logic for parent requirements.

    Frameworks & tools

    This skill operates on local Markdown-based documentation systems, specifically targeting workflows that use a docs/specpilot/ directory structure for requirement management.

    Why this beats prompting it yourself

    Manual archiving is prone to skipped steps, like forgetting to update the master index or losing the "why" behind a change. This skill enforces a strict documentation lifecycle that ensures every completed feature has a corresponding audit trail and technical summary.

    Use cases

    • Closing out a sprint by archiving all requirements marked as done in the implementation phase.
    • Documenting an iterative change that supersedes a previous requirement ID.
    • Generating a quick-reference summary for a complex feature to help new team members.
    • Cleaning up the in_progress workspace while keeping implementation notes for debugging.

    Known limitations

    Requires a specific directory structure (docs/specpilot/requirements/) to function. It only archives requirements that have existing draft files or were previously initialized in the index.

    Requires docs/specpilot/ directory structure. Only archives requirements marked as completed in development. Does not delete draft files.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    github
    Node.js
    specpilot-codex

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill automates the transition of active requirement drafts into a standardized archive format, ensuring your project index remains current and searchable without manual data entry. It prevents "documentation rot" by preserving the technical context of completed features in a structured, accessible way.

    The skill is designed for AI agents with local file system access and is optimized for Markdown-based workflows, specifically those following a `docs/specpilot/` directory structure. It integrates seamlessly with agents capable of reading, writing, and updating local text files.

    Your documentation must be organized within a `docs/specpilot/` directory, featuring an `index.md` file and a `requirements/` folder. The skill relies on these specific paths and a `REQ-000-template.md` file to maintain consistency across your archive.

    Yes, the skill is designed to handle iterative development by linking new requirement IDs to their legacy counterparts. It automatically updates status flows in your master index, ensuring that the evolution of a feature is clearly documented and traceable.

    You will receive the core skill logic designed for your AI agent, along with documentation on how to set up the necessary Markdown templates and directory structure for optimal performance.

    New in Technical Documentation