Claude Cursor Skill

dev-lifecycle

AI DevKit · Orchestrator for structured SDLC phase skills. Use when the user wants to run the full lifecycle or choose the next phase across requirements, design, planning, implementation, testing, and review.

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download codeaholicguy-ai-devkit-skills_dev-lifecycle-ac73d58.zip · 4 KB
codeaholicguy/ai-devkit 1639 257 forks Apache-2.0 Updated 1d ago
Part of codeaholicguy/ai-devkit — 24 skills

Install

skills CLI npx skills add https://github.com/codeaholicguy/ai-devkit/tree/main/skills/dev-lifecycle
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install codeaholicguy-ai-devkit@llmmart
Git git clone https://github.com/codeaholicguy/ai-devkit.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole codeaholicguy/ai-devkit collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Dev Lifecycle

Coordinate the phase-specific AI DevKit skills instead of running phase details directly.

Required phase skills:

  • dev-worktree for feature workspace setup and resume.
  • dev-requirements for phases 1-2: new requirement and requirements review.
  • dev-design for phase 3: design review.
  • dev-planning for phases 4 and 6: initial task planning and updates after implementation tasks.
  • dev-implementation for phases 5 and 7: execute plan and check implementation.
  • dev-testing for phase 8: write tests and verify coverage.
  • dev-review for phase 9: final code review.

Supporting skills:

  • memory for reusable project knowledge during clarification.
  • tdd for implementation tasks.
  • verify before completing implementation, implementation checks, testing claims, and review readiness.
  • task for optional progress tracing when the task command is usable.

Startup Validation

At the beginning of every dev-lifecycle run:

  1. Run npx ai-devkit@latest skill list to inspect currently installed project skills.
  2. Confirm the listed skills include all required phase skills and supporting skills.
  3. If any required skill is missing, run npx ai-devkit@latest skill add --built-in to install all AI DevKit built-in skills. Then rerun npx ai-devkit@latest skill list.
  4. If installation fails or a required skill is still missing, stop and report the missing skill names and command output summary. Do not run a phase without its skill.
  5. Run npx ai-devkit@latest lint to verify the configured AI docs structure.
  6. If working on a specific feature, run npx ai-devkit@latest lint --feature <name>.
  7. If lint fails because project docs are not initialized, run npx ai-devkit@latest init -a -e claude --built-in --yes, then rerun lint.
  8. Probe optional task tracing availability:
    • With a feature: npx ai-devkit@latest task list --name <feature-name> --json
    • Without a feature: npx ai-devkit@latest task list --json
    • Treat task tracing as available only if the read probe exits 0. If it fails, record task tracing as unavailable with the failed command and reason, then continue without task logging.
    • Never block lifecycle work only because the task command is missing or unusable.
  9. When working on a specific feature and task tracing is available:
    • Load and follow task before executing a phase.
    • Initialize or show the task named after the feature, mark active work, and emit phase/progress/next/blocker/evidence events per task.
    • Sequence task mutations; do not batch or parallelize mutations for the same feature.

Plan Before Execution

Before executing any phase:

  1. Identify the target feature, current docs state, branch/worktree context, and likely next phase.
  2. Propose a concise plan that names the phase skill to use, the docs/files to read, commands to run, expected edits, task tracing status and planned task events if tracing is available, and verification evidence.
  3. Wait for user approval before executing the plan unless the user already gave explicit approval for that exact phase execution.
  4. After approval, load and follow only the selected phase skill plus any explicitly required supporting skills. If tracing is available, the task skill is explicitly required.

Phase Routing

Phase Route to When
Setup. Workspace dev-worktree Starting or resuming feature work
1. New Requirement dev-requirements User wants to add a feature or start /new-requirement
2. Review Requirements dev-requirements Requirements doc needs validation
3. Review Design dev-design Design doc needs validation against requirements
4. Create Initial Plan dev-planning Requirements, design, and testing docs are ready for task breakdown
5. Execute Plan dev-implementation Ready to implement tasks from planning doc
6. Update Planning dev-planning Auto-trigger after completing any implementation task
7. Check Implementation dev-implementation Verify code matches design and docs
8. Write Tests dev-testing Add or verify test coverage
9. Code Review dev-review Final pre-push review

Sequential flow: setup -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 after each completed task -> 7 -> 8 -> 9.

Resuming Work

If the user wants to continue work on an existing feature:

  1. Use dev-worktree to identify and confirm the target branch/worktree.
  2. Run npx ai-devkit@latest lint --feature <feature-name> in the active context.
  3. Run the phase detector from the installed dev-lifecycle skill directory:
    • Resolve <skill-dir> as the directory containing this SKILL.md.
    • Run <skill-dir>/scripts/check-status.sh <feature-name>.
    • Use the suggested phase when proposing the execution plan.

Backward Transitions

Not every phase moves forward. When a phase reveals problems, route back:

  • Requirements review finds fundamental gaps: return to dev-requirements Phase 1.
  • Design review finds requirements gaps: return to dev-requirements Phase 2.
  • Design review finds design flaws: stay in dev-design and revise design.
  • Implementation check finds major deviations: return to dev-design if design is wrong, or dev-implementation if code is wrong.
  • Testing reveals design flaws: return to dev-design.
  • Review finds blocking issues: return to dev-implementation or dev-testing.

Rules

  • Use npx ai-devkit@latest lint and npx ai-devkit@latest lint --feature <name> to discover and validate the configured docs directory. Do not assume docs/ai; it is only the default.
  • Read existing configured AI docs before changes. Keep diffs minimal.
  • Keep feature names aligned with branch/worktree feature-<name>.
  • New feature docs come from npx ai-devkit@latest docs init-feature <name>. Use the paths returned by the command as authoritative.
  • Existing feature docs are the paths reported or validated by npx ai-devkit@latest lint --feature <name>. If you must infer manually, first resolve the configured docs directory from .ai-devkit.json paths.docs, falling back to docs/ai.
  • After each phase, summarize output and suggest the next phase.
  • Do not claim completion without fresh verification evidence.
  • When task tracing is available, follow task: create once, assign actor when known, mark active/blocked, set phase, record progress/next/evidence, and close only after final verification/review. If tracing is unavailable, include failed probe commands in the phase summary without blocking the lifecycle.
Files (ai-devkit)
  • agents
    • openai.yaml 269 B 
      interface:
  display_name: "Dev Lifecycle"
  short_description: "AI DevKit · Orchestrate SDLC phase skills end to end"
  default_prompt: "Use $dev-lifecycle to validate required phase skills, propose the next phase plan, and route execution to the right phase skill."
  • scripts
    • check-status.sh 2.4 KB 
      #!/usr/bin/env bash
set -euo pipefail

# Infer current lifecycle phase for a feature by checking doc state.
# Usage: check-status.sh <feature-name>

if [[ $# -lt 1 ]]; then
  echo "Usage: $0 <feature-name>"
  exit 1
fi

FEATURE="$1"
AI_DEVKIT_BIN="${AI_DEVKIT_BIN:-npx ai-devkit@latest}"

if [[ ! "$FEATURE" =~ ^[a-zA-Z0-9_-]+$ ]]; then
  echo "Error: feature name must contain only letters, digits, hyphens, and underscores"
  exit 1
fi

exists() { [[ -f "$1" ]]; }
nonempty() { [[ -f "$1" ]] && [[ -s "$1" ]]; }

LINT_OUTPUT="$($AI_DEVKIT_BIN lint --feature "$FEATURE" 2>/dev/null || true)"

lint_doc() {
  local phase="$1"
  awk -v phase="$phase" '
    /^=== Feature:/ { in_feature = 1; next }
    /^=== Git:/ { in_feature = 0 }
    in_feature && $0 ~ "\\]  .*/" phase "/" {
      sub(/^[^]]*][[:space:]]+/, "", $0)
      print
      exit
    }
  ' <<< "$LINT_OUTPUT"
}

REQ="$(lint_doc requirements)"
DES="$(lint_doc design)"
PLN="$(lint_doc planning)"
IMP="$(lint_doc implementation)"
TST="$(lint_doc testing)"

if [[ -z "$REQ" || -z "$DES" || -z "$PLN" || -z "$IMP" || -z "$TST" ]]; then
  echo "Error: could not resolve feature docs from 'ai-devkit lint --feature $FEATURE'"
  echo "Run: $AI_DEVKIT_BIN lint --feature $FEATURE"
  exit 1
fi

echo "=== Status: $FEATURE ==="

# Check which docs exist
for doc in "$REQ" "$DES" "$PLN" "$IMP" "$TST"; do
  if exists "$doc"; then
    echo "[EXISTS] $doc"
  else
    echo "[MISS]   $doc"
  fi
done

# Count planning tasks if planning doc exists
if exists "$PLN"; then
  TOTAL=$(grep -Ec '^[[:space:]]*- \[' "$PLN" 2>/dev/null || true)
  DONE=$(grep -Ec '^[[:space:]]*- \[x\]' "$PLN" 2>/dev/null || true)
  TOTAL=${TOTAL:-0}
  DONE=${DONE:-0}
  TODO=$((TOTAL - DONE))
  echo ""
  echo "Planning: $DONE/$TOTAL tasks done, $TODO remaining"
fi

# Infer phase
echo ""
echo "--- Suggested phase ---"
if ! exists "$REQ"; then
  echo "Phase 1 (New Requirement) — no requirements doc yet"
elif ! exists "$DES"; then
  echo "Phase 1 (New Requirement) — requirements exist but no design doc"
elif ! exists "$PLN"; then
  echo "Phase 4 (Create Initial Plan) — design exists but no planning doc"
elif exists "$PLN" && [[ ${TODO:-0} -gt 0 ]]; then
  echo "Phase 5 (Execute Plan) — $TODO tasks remaining"
elif exists "$PLN" && [[ ${TODO:-0} -eq 0 ]] && [[ ${TOTAL:-0} -gt 0 ]]; then
  echo "Phase 7 (Check Implementation) — all tasks done, verify against design"
else
  echo "Phase 2 (Review Requirements) — docs exist, review for completeness"
fi
  • SKILL.md 6.7 KB 
    ---
name: dev-lifecycle
description: AI DevKit · Orchestrator for structured SDLC phase skills. Use when the user wants to run the full lifecycle or choose the next phase across requirements, design, planning, implementation, testing, and review.
---

# Dev Lifecycle

Coordinate the phase-specific AI DevKit skills instead of running phase details directly.

Required phase skills:

- `dev-worktree` for feature workspace setup and resume.
- `dev-requirements` for phases 1-2: new requirement and requirements review.
- `dev-design` for phase 3: design review.
- `dev-planning` for phases 4 and 6: initial task planning and updates after implementation tasks.
- `dev-implementation` for phases 5 and 7: execute plan and check implementation.
- `dev-testing` for phase 8: write tests and verify coverage.
- `dev-review` for phase 9: final code review.

Supporting skills:

- `memory` for reusable project knowledge during clarification.
- `tdd` for implementation tasks.
- `verify` before completing implementation, implementation checks, testing claims, and review readiness.
- `task` for optional progress tracing when the task command is usable.

## Startup Validation

At the beginning of every `dev-lifecycle` run:

1. Run `npx ai-devkit@latest skill list` to inspect currently installed project skills.
2. Confirm the listed skills include all required phase skills and supporting skills.
3. If any required skill is missing, run `npx ai-devkit@latest skill add --built-in` to install all AI DevKit built-in skills. Then rerun `npx ai-devkit@latest skill list`.
4. If installation fails or a required skill is still missing, stop and report the missing skill names and command output summary. Do not run a phase without its skill.
5. Run `npx ai-devkit@latest lint` to verify the configured AI docs structure.
6. If working on a specific feature, run `npx ai-devkit@latest lint --feature <name>`.
7. If lint fails because project docs are not initialized, run `npx ai-devkit@latest init -a -e claude --built-in --yes`, then rerun lint.
8. Probe optional task tracing availability:
   - With a feature: `npx ai-devkit@latest task list --name <feature-name> --json`
   - Without a feature: `npx ai-devkit@latest task list --json`
   - Treat task tracing as available only if the read probe exits 0. If it fails, record task tracing as unavailable with the failed command and reason, then continue without task logging.
   - Never block lifecycle work only because the task command is missing or unusable.
9. When working on a specific feature and task tracing is available:
   - Load and follow `task` before executing a phase.
   - Initialize or show the task named after the feature, mark active work, and emit phase/progress/next/blocker/evidence events per `task`.
   - Sequence task mutations; do not batch or parallelize mutations for the same feature.

## Plan Before Execution

Before executing any phase:

1. Identify the target feature, current docs state, branch/worktree context, and likely next phase.
2. Propose a concise plan that names the phase skill to use, the docs/files to read, commands to run, expected edits, task tracing status and planned task events if tracing is available, and verification evidence.
3. Wait for user approval before executing the plan unless the user already gave explicit approval for that exact phase execution.
4. After approval, load and follow only the selected phase skill plus any explicitly required supporting skills. If tracing is available, the `task` skill is explicitly required.

## Phase Routing

| Phase | Route to | When |
|---|---|---|
| Setup. Workspace | `dev-worktree` | Starting or resuming feature work |
| 1. New Requirement | `dev-requirements` | User wants to add a feature or start `/new-requirement` |
| 2. Review Requirements | `dev-requirements` | Requirements doc needs validation |
| 3. Review Design | `dev-design` | Design doc needs validation against requirements |
| 4. Create Initial Plan | `dev-planning` | Requirements, design, and testing docs are ready for task breakdown |
| 5. Execute Plan | `dev-implementation` | Ready to implement tasks from planning doc |
| 6. Update Planning | `dev-planning` | Auto-trigger after completing any implementation task |
| 7. Check Implementation | `dev-implementation` | Verify code matches design and docs |
| 8. Write Tests | `dev-testing` | Add or verify test coverage |
| 9. Code Review | `dev-review` | Final pre-push review |

Sequential flow: setup -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 after each completed task -> 7 -> 8 -> 9.

## Resuming Work

If the user wants to continue work on an existing feature:

1. Use `dev-worktree` to identify and confirm the target branch/worktree.
2. Run `npx ai-devkit@latest lint --feature <feature-name>` in the active context.
3. Run the phase detector from the installed `dev-lifecycle` skill directory:
   - Resolve `<skill-dir>` as the directory containing this `SKILL.md`.
   - Run `<skill-dir>/scripts/check-status.sh <feature-name>`.
   - Use the suggested phase when proposing the execution plan.

## Backward Transitions

Not every phase moves forward. When a phase reveals problems, route back:

- Requirements review finds fundamental gaps: return to `dev-requirements` Phase 1.
- Design review finds requirements gaps: return to `dev-requirements` Phase 2.
- Design review finds design flaws: stay in `dev-design` and revise design.
- Implementation check finds major deviations: return to `dev-design` if design is wrong, or `dev-implementation` if code is wrong.
- Testing reveals design flaws: return to `dev-design`.
- Review finds blocking issues: return to `dev-implementation` or `dev-testing`.

## Rules

- Use `npx ai-devkit@latest lint` and `npx ai-devkit@latest lint --feature <name>` to discover and validate the configured docs directory. Do not assume `docs/ai`; it is only the default.
- Read existing configured AI docs before changes. Keep diffs minimal.
- Keep feature names aligned with branch/worktree `feature-<name>`.
- New feature docs come from `npx ai-devkit@latest docs init-feature <name>`. Use the paths returned by the command as authoritative.
- Existing feature docs are the paths reported or validated by `npx ai-devkit@latest lint --feature <name>`. If you must infer manually, first resolve the configured docs directory from `.ai-devkit.json` `paths.docs`, falling back to `docs/ai`.
- After each phase, summarize output and suggest the next phase.
- Do not claim completion without fresh verification evidence.
- When task tracing is available, follow `task`: create once, assign actor when known, mark active/blocked, set phase, record progress/next/evidence, and close only after final verification/review. If tracing is unavailable, include failed probe commands in the phase summary without blocking the lifecycle.

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related

Claude Prompt
Tighten-my-prose editing prompt
Claude Skill
Adversarial code-review skill for Claude
Claude Workflow
Deep-research workflow (fan-out + verify)
Claude Skill
Conventional-commit writer for Claude