playbooks

home / skills / oimiragieo / agent-studio / artifact-lifecycle

artifact-lifecycle skill

/.claude/skills/artifact-lifecycle

This skill streamlines artifact lifecycle management by automating creation, updates, deprecation, and integration across skills, agents, hooks, workflows,

npx playbooks add skill oimiragieo/agent-studio --skill artifact-lifecycle

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

Files (11)
SKILL.md
4.0 KB
---
name: artifact-lifecycle
description: Unified lifecycle management for all framework artifacts (skills, agents, hooks, workflows, templates, schemas)
version: 1.0.0
author: Claude Code Enterprise Framework
triggers:
  - 'create skill'
  - 'create agent'
  - 'update skill'
  - 'deprecate'
  - 'artifact lifecycle'
metadata:
  skill-author: Claude Code Enterprise Framework
  category: orchestration
  complexity: medium
---

# Artifact Lifecycle Skill

Convenience wrapper for the unified artifact lifecycle workflow.

## Overview

This skill provides a simplified interface to the comprehensive artifact lifecycle management workflow at `.claude/workflows/core/skill-lifecycle.md`.

## When to Use

Use this skill when you need to:

- Create a new artifact (skill, agent, hook, workflow, template, schema)
- Update an existing artifact
- Deprecate an artifact with migration guidance
- Check if an artifact already exists

## Quick Start

```javascript
// Invoke this skill
Skill({ skill: 'artifact-lifecycle' });
```

## Workflow Reference

**Full Workflow:** `.claude/workflows/core/skill-lifecycle.md`

## Phases

### Phase 1: Discovery

Check if artifact exists, compare versions.

**Agent:** architect
**Output:** Discovery report with recommendations

### Phase 2: Decision

Determine action: CREATE, UPDATE, or DEPRECATE.

**Agent:** planner
**Output:** Action plan with tasks

### Phase 3: Action

Execute the determined action.

**Agent:** developer + appropriate creator skill
**Tools:**

- `Skill({ skill: "skill-creator" })` for skills
- `Skill({ skill: "agent-creator" })` for agents
- `Skill({ skill: "hook-creator" })` for hooks
- `Skill({ skill: "workflow-creator" })` for workflows

### Phase 4: Integration

Update registries, catalogs, and CLAUDE.md.

**Agent:** developer
**Updates:**

- creator-registry.json
- skill-catalog.md (for skills)
- CLAUDE.md Section 3 (for agents) or Section 8.5/8.6 (for skills/workflows)

### Phase 5: Validation

Test integration and verify references.

**Agent:** qa
**Checks:**

- Artifact invocable
- References valid
- No broken cross-references

## Usage Examples

### Create New Skill

```
User: "Create a skill for Kubernetes deployment"

Router spawns with:
Skill({ skill: "artifact-lifecycle" })

Workflow determines: CREATE mode
Invokes: skill-creator
Updates: registry, catalog, CLAUDE.md
Validates: skill invocable
```

### Update Existing Agent

```
User: "Update the devops agent to support Terraform Cloud"

Router spawns with:
Skill({ skill: "artifact-lifecycle" })

Workflow determines: UPDATE mode
Version: 1.0.0 → 1.1.0
Updates: agent file, CHANGELOG
Validates: agent referenced correctly
```

### Deprecate Workflow

```
User: "Deprecate the old deployment workflow"

Router spawns with:
Skill({ skill: "artifact-lifecycle" })

Workflow determines: DEPRECATE mode
Adds: deprecation notice, migration guide
Updates: CLAUDE.md with replacement reference
Validates: no broken references
```

## Configuration

| Parameter     | Values                                         | Default     |
| ------------- | ---------------------------------------------- | ----------- |
| artifact_type | skill, agent, hook, workflow, template, schema | auto-detect |
| operation     | create, update, deprecate, integrate           | auto-detect |
| version_bump  | major, minor, patch                            | minor       |

## Memory Protocol

1. Read `.claude/context/memory/learnings.md` before starting
2. Record decisions to `.claude/context/memory/decisions.md`
3. Record issues to `.claude/context/memory/issues.md`

## Related Skills

- `skill-creator` - Direct skill creation
- `agent-creator` - Direct agent creation
- `workflow-creator` - Direct workflow creation
- `codebase-integration` - External artifact integration

## Related Workflows

- `.claude/workflows/core/skill-lifecycle.md` - Full lifecycle workflow
- `.claude/workflows/core/external-integration.md` - External artifact integration
- `.claude/workflows/core/router-decision.md` - Router decision flow

Overview

This skill provides a unified, opinionated workflow for managing the full lifecycle of framework artifacts: skills, agents, hooks, workflows, templates, and schemas. It simplifies discovery, decision-making, execution, integration, and validation into a single interface so teams can create, update, or deprecate artifacts reliably. The skill automates registry and documentation updates and records lifecycle decisions to project memory.

How this skill works

The skill inspects the codebase and registries to discover whether an artifact exists and compares versions and references. Based on discovery it chooses an action—CREATE, UPDATE, or DEPRECATE—then invokes the appropriate creator or developer steps to perform the change. After action, it updates registries, catalogs, and documentation (including CLAUDE.md) and runs validation checks to ensure the artifact is invocable and all references remain valid. All key decisions, migrations, and issues are recorded to the project memory protocol.

When to use it

  • When creating a new framework artifact (skill, agent, hook, workflow, template, or schema).
  • When updating an existing artifact and you need versioning, change logs, and registry updates.
  • When deprecating an artifact and you need to publish migration guidance and replacement references.
  • When you need to verify whether an artifact already exists and compare versions before acting.
  • When you want to automate integration steps such as registry, catalog, and documentation updates.

Best practices

  • Run the discovery phase before proposing changes to avoid duplicate artifacts or version conflicts.
  • Provide a clear migration guide when deprecating artifacts and include replacement references.
  • Use semantic version bumps (major/minor/patch) and record the rationale to the decisions memory.
  • Validate artifacts after integration: ensure invocable endpoints and no broken cross-references.
  • Update changelogs and registries as part of the same lifecycle transaction to keep metadata consistent.

Example use cases

  • Create a new Kubernetes deployment skill and automatically add it to the skill catalog and registry.
  • Update a devops agent to support Terraform Cloud, bump the version, and update the CHANGELOG and references.
  • Deprecate an outdated deployment workflow and publish a migration guide with replacement workflow links.
  • Integrate an externally provided template into the codebase and ensure registries and documentation are updated.
  • Run a discovery pass to detect duplicate schemas and recommend consolidation or version alignment.

FAQ

What artifact types are supported?

Supported types: skill, agent, hook, workflow, template, and schema; the skill auto-detects when possible.

How are decisions recorded?

Decisions, issues, and learnings are written to the project memory files so the team retains a traceable history.

Does the skill run validation automatically?

Yes. After integration it runs validation checks to ensure the artifact is invocable and references are valid.