home / skills / athola / claude-night-market / storage-templates

storage-templates skill

safe

/plugins/leyline/skills/storage-templates

This skill helps you design structured storage systems with lifecycle-aware templates, consistent naming, and documentation guidelines for reusable knowledge

npx playbooks add skill athola/claude-night-market --skill storage-templates

Review the files below or copy the command above to add this skill to your agents.

Files (5)

SKILL.md

5.0 KB

---
name: storage-templates
description: Consult this skill when designing storage and documentation systems.
  Use when organizing knowledge storage, managing configuration lifecycle, creating
  structured documentation, establishing naming conventions. Do not use when simple
  storage without lifecycle or structure needs.
category: infrastructure
tags:
- templates
- storage
- lifecycle
- maturity
- organization
- patterns
dependencies: []
provides:
  infrastructure:
  - templates
  - lifecycle-management
  - naming-conventions
  patterns:
  - maturity-stages
  - template-structures
  - file-organization
usage_patterns:
- knowledge-management
- documentation-systems
- configuration-management
complexity: beginner
estimated_tokens: 600
progressive_loading: true
modules:
- modules/template-patterns.md
- modules/lifecycle-stages.md
---
## Table of Contents

- [Overview](#overview)
- [When to Use](#when-to-use)
- [Core Concepts](#core-concepts)
- [Template Types](#template-types)
- [Maturity Lifecycle](#maturity-lifecycle)
- [Quick Start](#quick-start)
- [Basic Template Structure](#basic-template-structure)
- [Core Content](#core-content)
- [Metadata](#metadata)
- [File Naming Conventions](#file-naming-conventions)
- [Domain Applications](#domain-applications)
- [Common Patterns](#common-patterns)
- [Promotion Workflow](#promotion-workflow)
- [Template Selection Guide](#template-selection-guide)
- [Integration Pattern](#integration-pattern)
- [Detailed Resources](#detailed-resources)
- [Exit Criteria](#exit-criteria)


# Storage Templates

## Overview

Generic template patterns and lifecycle management for structured content storage. Provides reusable templates, maturity progression models, and file naming conventions that work across different storage domains.

## When To Use

- Building knowledge management systems
- Organizing documentation with maturity stages
- Need consistent file naming patterns
- Want template-driven content creation
- Implementing lifecycle-based workflows

## When NOT To Use

- Simple storage without lifecycle or structure needs

## Core Concepts

### Template Types

| Type | Purpose | Maturity | Lifetime |
|------|---------|----------|----------|
| **Evergreen** | Stable, proven knowledge | High | Permanent |
| **Growing** | Active development | Medium | 1-3 months |
| **Seedling** | Early ideas | Low | 1-2 weeks |
| **Reference** | Tool/version-specific | N/A | Until deprecated |

### Maturity Lifecycle

```
seedling → growing → evergreen → archive
    ↓         ↓          ↓           ↓
 1-2 weeks  1-3 months  permanent  deprecated
```
**Verification:** Run the command with `--help` flag to verify availability.

## Quick Start

### Basic Template Structure

```yaml
---
title: [Content Title]
created: [YYYY-MM-DD]
maturity: seedling|growing|evergreen|reference
tags: [relevant, tags]
---

# [Title]

## Core Content
[Main information]

## Metadata
[Context and attribution]
```
**Verification:** Run the command with `--help` flag to verify availability.

### File Naming Conventions

| Type | Pattern | Example |
|------|---------|---------|
| Evergreen | `topic-name.md` | `functional-core-pattern.md` |
| Growing | `topic-name.md` | `async-patterns.md` |
| Seedling | `YYYY-MM-DD-topic.md` | `2025-12-05-template-idea.md` |
| Reference | `tool-version.md` | `python-3.12-features.md` |

### Domain Applications

Add domain-specific fields to templates:
- **memory-palace**: `palace`, `district` for knowledge organization
- **sanctum**: `scope`, `version` for commit templates
- **spec-kit**: `phase`, `status` for specifications

See `modules/template-patterns.md` for detailed examples.

## Common Patterns

### Promotion Workflow

**Seedling → Growing**:
- Accessed more than once
- Connected to other entries
- Expanded with new insights

**Growing → Evergreen**:
- Proven useful over 3+ months
- Stable, not frequently edited
- Well-connected in system

**Evergreen → Archive**:
- Superseded by newer knowledge
- Technology/approach deprecated
- No longer applicable

### Template Selection Guide

| Stability | Purpose | Template |
|-----------|---------|----------|
| Proven | Long-term | Evergreen |
| Evolving | Active development | Growing |
| Experimental | Exploration | Seedling |
| Versioned | External reference | Reference |

## Integration Pattern

```yaml
# In your skill's frontmatter
dependencies: [leyline:storage-templates]
```
**Verification:** Run the command with `--help` flag to verify availability.

## Detailed Resources

- **Templates**: See `modules/template-patterns.md` for detailed structures
- **Lifecycle**: See `modules/lifecycle-stages.md` for maturity progression

## Exit Criteria

- Template selected for use case
- File naming convention applied
- Maturity stage assigned
- Promotion criteria understood
## Troubleshooting

### Common Issues

**Command not found**
Ensure all dependencies are installed and in PATH

**Permission errors**
Check file permissions and run with appropriate privileges

**Unexpected behavior**
Enable verbose logging with `--verbose` flag

Overview

This skill provides reusable storage and documentation templates plus a maturity lifecycle to organize structured content consistently. It helps teams design file naming conventions, metadata frontmatter, and promotion workflows so knowledge remains discoverable and maintainable. Use it to standardize content creation across domains and track content maturity from idea to archive.

How this skill works

The skill supplies template types (seedling, growing, evergreen, reference) with recommended frontmatter, file-name patterns, and domain-specific fields. It defines promotion criteria and lifecycle timelines so items move predictably from experimental drafts to stable references or archive. Integrations are straightforward: include the templates and follow the frontmatter and naming conventions to opt into the lifecycle.

When to use it

Designing knowledge management or documentation systems with lifecycle stages
Creating repeatable templates for notes, specs, or operational docs
Enforcing consistent file naming and metadata across projects
Managing content promotion from draft to stable reference
Adding domain-specific fields (memory-palace, sanctum, spec-kit) to templates

Best practices

Choose a maturity type up front and include it in frontmatter (seedling/growing/evergreen/reference)
Name files according to the suggested patterns to enable automated tooling and filtering
Keep core content and metadata separated in frontmatter for clarity and processing
Set clear promotion criteria and review cadence before moving items between stages
Use tags and well-chosen domain fields to connect related entries across the system

Example use cases

Drafting experimental ideas as seedling templates with date-prefixed filenames
Maintaining living design patterns as growing templates during active development
Publishing stable processes or reference guides as evergreen templates with simple names
Capturing tool-specific notes as reference templates tied to version identifiers
Integrating templates into CI or publishing workflows to auto-promote based on usage

FAQ

How long should content stay in each maturity stage?

Typical windows: seedling 1–2 weeks, growing 1–3 months, evergreen permanent; adjust by team needs and usage signals.

What file naming pattern should I use for early ideas?

Use a date-prefixed pattern like YYYY-MM-DD-topic.md for seedling entries to sort chronologically and signal temporariness.