Skip to content
Back to search

loopkit-marketplace

MarketplaceWorks with Claude CodeGitHub

Standalone marketplace for loopkit — 41 skills + minimal harness.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/archive228--loopkit/badge.svg)](/listings/archive228--loopkit)

HTML

<a href="/listings/archive228--loopkit"><img src="/api/listings/archive228--loopkit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

# 1. drop the harness into your project (safe: skips existing files)
curl -fsSL https://raw.githubusercontent.com/Archive228/loopkit/main/install.sh | bash

# 2. open Claude Code / Cursor / Codex in the same directory
claude

# 3. write a one-line spec, then let the loop drive
echo "STATUS: not-started" > IMPLEMENTATION_PLAN.md
./run.sh

That's it. Skills load only when a task triggers them. The verifier subagent closes the loop.

> Existing files are kept by default. Pass `FORCE=1` to overwrite, or `BACKUP=1` to snapshot your current `.claude/` to `.claude.bak-<timestamp>/` before writing.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 20 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "loopkit-marketplace",
  3. "description": "Standalone marketplace for loopkit — 41 skills + minimal harness.",
  4. "owner": {
  5. "name": "Archive228",
  6. "url": "https://github.com/Archive228"
  7. },
  8. "plugins": [
  9. {
  10. "name": "loopkit",
  11. "description": "33 battle-tested skills + a minimal harness for Claude Code, Cursor, Codex, Gemini CLI.",
  12. "version": "0.2.0",
  13. "source": "./",
  14. "author": {
  15. "name": "Archive228",
  16. "url": "https://github.com/Archive228"
  17. }
  18. }
  19. ]
  20. }
README.md · README · 324 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. ```
  3. ▄█ ▄██████▄ ▄██████▄ ▄███████▄ ▄█ ▄█▄ ▄█ ███
  4. ███ ███ ███ ███ ███ ███ ███ ███ ▄███▀ ███ ▀█████████▄
  5. ███ ███ ███ ███ ███ ███ ███ ███▐██▀ ███▌ ▀███▀▀██
  6. ███ ███ ███ ███ ███ ███ ███ ▄█████▀ ███▌ ███ ▀
  7. ███ ███ ███ ███ ███ ▀█████████▀ ▀▀█████▄ ███▌ ███
  8. ███ ███ ███ ███ ███ ███ ███▐██▄ ███ ███
  9. ███▌ ▄ ███ ███ ███ ███ ███ ███ ▀███▄███ ███
  10. █████▄▄██ ▀██████▀ ▀██████▀ ▄████▀ ███ ▀█▀ █▀ ▄████▀
  11. ```
  12. **A drop-in `.claude/` harness + 49 battle-tested skills for coding agents.**
  13. Plan → Act → Verify, enforced by files on disk. Ships the floor, keeps out of your way.
  14. [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
  15. [![Skills](https://img.shields.io/badge/skills-49-black.svg)](#the-library)
  16. [![Tracks](https://img.shields.io/badge/tracks-10-black.svg)](#the-library)
  17. [![Compatible](https://img.shields.io/badge/agents-Claude%20Code%20%C2%B7%20Cursor%20%C2%B7%20Codex%20%C2%B7%20Gemini-black.svg)](#compatibility)
  18. [![skills.sh](https://img.shields.io/badge/skills.sh-Archive228%2Floopkit-green.svg)](https://www.skills.sh/)
  19. </div>
  20. ---
  21. ## 30-second quickstart
  22. ```bash
  23. # 1. drop the harness into your project (safe: skips existing files)
  24. curl -fsSL https://raw.githubusercontent.com/Archive228/loopkit/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 32 on GitHub
  25. # 2. open Claude Code / Cursor / Codex in the same directory
  26. claude
  27. # 3. write a one-line spec, then let the loop drive
  28. echo "STATUS: not-started" > IMPLEMENTATION_PLAN.md
  29. ./run.sh
  30. ```
  31. That's it. Skills load only when a task triggers them. The verifier subagent closes the loop.
  32. > Existing files are kept by default. Pass `FORCE=1` to overwrite, or `BACKUP=1` to snapshot your current `.claude/` to `.claude.bak-<timestamp>/` before writing.
  33. ## Cherry-pick a single skill
  34. Prefer one skill over the whole floor?
  35. ```bash
  36. npx -p claude-loopkit loopkit-add adversarial-verify
  37. ```
  38. Installs only that skill into `./.claude/skills/`. Pass `--force` to overwrite an existing copy. Browse the catalog at [skills/](./skills).
  39. ---
  40. ## What loopkit is (and isn't)
  41. Straight from my own `.claude/` directory. This is the loadout I actually reach for — not a methodology, not a lifecycle, not a framework.
  42. **loopkit is:**
  43. - A working harness: settings, hooks, verifier subagent, loop runner. Files on disk, no runtime.
  44. - 49 small skills that load only when relevant, so the agent specializes instead of guessing.
  45. - Cross-agent. Every skill is a plain markdown doc with a YAML header — nothing Claude-specific inside the skill body.
  46. **loopkit isn't:**
  47. - A new methodology to learn. No BMAD, no Prime Radiant, no 6-phase lifecycle. If a skill doesn't help the loop advance, it isn't here.
  48. - A wrapper CLI. No daemon, no server, no runtime state. `run.sh` is 8 lines.
  49. - A vendor lock-in. Fork it, gut it, keep the three skills you like. MIT.
  50. ---
  51. ## The loop
  52. Every skill fires inside this shape. The harness enforces it.
  53. ```
  54. PLAN ──▶ ACT ──▶ VERIFY
  55. ▲ │
  56. └────── revise ──────┘
  57. ```
  58. - **PLAN** — `spec-first`, `context-budget`, `tool-restraint`, `planner-spec-expand`, `sprint-contract` load here.
  59. - **ACT** — domain skills load here (debug, security, testing, refactor, docs, data, git-ops).
  60. - **VERIFY** — `adversarial-verify` + `evaluator-calibration` + the verifier subagent close the loop before anything ships.
  61. Full theory: **[Loop and Harness engineering: 7 files, 5 steps](./docs/effective-harnesses-v03.md)**.
  62. ---
  63. ## File-by-file: what you get
  64. ```
  65. your-project/
  66. ├── .claude/
  67. │ ├── CLAUDE.md # 60-line standing context (edit for your stack)
  68. │ ├── settings.json # permission allowlist + format-on-write hook
  69. │ ├── agents/
  70. │ │ └── verifier.md # adversarial verifier subagent (Haiku, JSON-out)
  71. │ ├── hooks/ # session-start bootstrap
  72. │ └── skills/ # 49 skills, symlinked or copied
  73. ├── .mcp.json # MCP server wiring (github, context7)
  74. ├── MEMORY.md # cross-session memory index (keep terse)
  75. └── run.sh # Plan → Act → Verify loop runner
  76. ```
  77. Every file below is opinionated on purpose. Change what doesn't fit; the loop still works.
  78. ### `.claude/CLAUDE.md` — standing context
  79. 60 lines, no more. The tax on every turn. Stack, layout, commands, conventions, the three things the agent must never do. Prune weekly.
  80. ### `.claude/settings.json` — permissions + hooks
  81. Allowlist for read-only Bash and Read; deny-list for `rm -rf` and force-push. `PostToolUse` hook runs Prettier on every Edit/Write so the diff stays reviewable.
  82. ### `.claude/agents/verifier.md` — the adversarial subagent
  83. Runs on Haiku. Reads the diff assuming it's broken. Checks the 11 "fake done" shortcuts (see `skills/adversarial-verify`). Returns JSON. Does not propose fixes, does not run code, does not be polite. This is the load-bearing piece.
  84. ### `.claude/hooks/` — session-start bootstrap
  85. Fires when the agent opens the project. Reminds it of the loop shape and points at `CLAUDE.md`. Zero runtime cost.
  86. ### `.claude/skills/` — the 49-skill library
  87. Each skill: YAML frontmatter with `name` + `description`, a short body, no runtime dependencies. Loads only when its trigger fires. See the full list below.
  88. ### `.mcp.json` — MCP wiring
  89. GitHub + Context7 by default. Add your own; the harness doesn't care.
  90. ### `MEMORY.md` — cross-session index
  91. Preferences, decisions, feedback you keep re-applying. Prune every session or it becomes rot.
  92. ### `run.sh` — the loop runner
  93. 8 lines. Reads `PROMPT.md` + `IMPLEMENTATION_PLAN.md`, does one step, verifies, loops until `STATUS: done`. Fresh context each turn; state lives on disk.
  94. ---
  95. ## The library
  96. **49 skills across 10 tracks.** Each one: name → what it does → when it fires.
  97. ### agent/llm — how the agent behaves
  98. - **context-budget** — trim the working set → *before large reads or long sessions*
  99. - **spec-first** — write the contract before code → *any new feature or endpoint*
  100. - **tool-restraint** — pick the smallest tool that fits → *avoids Bash-for-everything drift*
  101. - **subagent-fanout** — parallelize independent probes → *research/audit tasks*
  102. ### loop & harness — long-running, multi-session, multi-agent discipline
  103. - **planner-spec-expand** — 1–4 sentence brief → full ambitious spec with design language and ordered feature list → *starting a fresh project or major feature*
  104. - **sprint-contract** — negotiate "done" as script-decidable predicates before code → *entering an implementation sprint with an evaluator in the loop*
  105. - **feature-list-json** — enumerate every feature as strict JSON, `passes:false`, editable-passes-only → *multi-session builds*
  106. - **init-script-contract** — idempotent `init.sh` + `test.sh`/`stop.sh`/`reset.sh` siblings, under 120s → *setting up a repo for multi-session agent work*
  107. - **progress-reading-protocol** — fixed 6-step session-open ritual (pwd → progress → git log → feature-count → init → smoke-test) → *any session bootstrapping into an existing project*
  108. - **self-eval-bias** — interrupt confidently-praise-my-own-work drift → *when an agent is about to declare success on its own output*
  109. - **evaluator-calibration** — few-shot the reviewer persona with rubric anchors to keep skepticism from drifting lenient → *before a long autonomous run with a reviewer agent*
  110. - **harness-stripping** — remove one harness component at a time and measure impact, on every model release → *when a new model lands, before piling on more scaffolding*
  111. ### debug
  112. - **systematic-debugging** — hypothesis → test → narrow → *any bug you can't one-shot*
  113. - **read-the-trace** — extract the actual failure from noise → *stack traces, CI logs*
  114. - **bisect-regression** — git-bisect discipline → *"it worked yesterday"*
  115. ### security
  116. - **owasp-review** — top-10 pass on a diff → *before merging user-facing changes*
  117. - **authz-check** — verify every route enforces its policy → *auth surface changes*
  118. - **input-validation** — validate at the edge → *any handler taking external data*
  119. - **secret-scan** — catch keys before commit → *pre-push, PR review*
  120. - **dependency-audit** — CVE + license triage → *lockfile changes*
  121. ### frontend
  122. - **design-system** — reuse tokens, don't invent them → *any UI change*
  123. - **a11y-pass** — semantics + keyboard + contrast → *before shipping a screen*
  124. - **loading-empty-error-states** — all four states, not just happy path → *any async view*
  125. ### testing
  126. - **write-failing-test-first** — red before green → *behavior changes, bug fixes*
  127. - **flaky-hunter** — reproduce, isolate, quarantine → *intermittent CI reds*
  128. - **coverage-gaps** — find behavior with no test → *before declaring "done"*
  129. - **contract-test** — pin the API shape → *service boundaries*
  130. ### refactor
  131. - **kill-dead-code** — prove unreachable, then delete → *cleanup passes*
  132. - **simplify** — collapse indirection you don't need → *code review, "too clever"*
  133. - **reduce-nesting** — early returns, guard clauses → *reading fatigue*
  134. ### docs
  135. - **changelog-from-diff** — human-readable release notes → *tagging a version*
  136. - **decision-record** — ADR for the "why" → *architectural choices*
  137. - **readme-audit** — check onboarding path from cold → *before public share*
  138. ### data
  139. - **sql-review** — indexes, N+1, plan → *any non-trivial query*
  140. - **migration-writer** — reversible, zero-downtime → *schema changes*
  141. - **schema-diff** — compare shapes, catch drift → *env sync*
  142. ### git/ops
  143. - **clean-commits** — atomic, message-first → *before PR*
  144. - **pr-from-diff** — summary the reviewer will actually read → *opening a PR*
  145. - **rebase-safely** — no lost commits → *history cleanup*
  146. - **revert-surgical** — undo only the offending change → *bad merges*
  147. ### review
  148. - **adversarial-verify** — the 11 shortcuts agents take to fake "done" → *before flipping any task to complete*
  149. - **verification-before-completion** — run the exact command, read the output, then claim → *before any "done" claim*
  150. ---
  151. ## Reference checklists (loaded on demand)
  152. Skills stay short. When one needs a longer reference, it points here:
  153. - [Definition of Done](./docs/checklists/definition-of-done.md) — what "shipped" actually means
  154. - [Red Flags](./docs/checklists/red-flags.md) — 15 patterns the verifier looks for
  155. - [Rationalizations](./docs/checklists/rationalizations.md) — excuses agents give and their rebuttals
  156. ## Slash commands
  157. Three commands ship in `.claude/commands/`. Each loads a small set of skills and drives a fixed protocol — no hidden state.
  158. - **Spec first: `/spec`** — write `PROMPT.md` and `IMPLEMENTATION_PLAN.md` before the agent touches code.
  159. - **Adversarial verify: `/verify`** — assume the diff is broken; run the 11-shortcut checklist and dispatch the verifier subagent.
  160. - **One-shot polish pass: `/polish`** — batch quality pass over the current diff (simplify → reduce-nesting → kill-dead-code → a11y-pass → loading-empty-error-states → readme-audit).
  161. ---
  162. ## Install
  163. Pick one. All three drop the same files into your current project.
  164. ```bash
  165. # via curl (no Node required, recommended)
  166. curl -fsSL https://raw.githubusercontent.com/Archive228/loopkit/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 230 on GitHub
  167. # via skills.sh (works with any agent that reads SKILL.md)
  168. npx skills add Archive228/loopkit
  169. # via git (if you want to fork first)
  170. git clone https://github.com/Archive228/loopkit
  171. cp -r loopkit/.claude your-project/
  172. ```
  173. **Options for the curl installer:**
  174. | Env var | Effect |
  175. |---|---|
  176. | `FORCE=1` | Overwrite existing files instead of skipping |
  177. | `BACKUP=1` | Snapshot existing `.claude/` to `.claude.bak-<timestamp>/` before writing |
  178. | `DEST=/path` | Install into a specific directory instead of `$PWD` |
  179. | `LOOPKIT_REF=<branch>` | Install from a specific branch/tag (default `main`) |
  180. The installer prints every write, verifies the `claude` CLI is on your PATH afterward, and exits non-zero if anything critical failed.
  181. ---
  182. ## Portability
  183. Not tied to Claude. See [docs/portability.md](docs/portability.md).
  184. ---
  185. ## Compatibility
  186. Works with anything that reads `SKILL.md`:
  187. **Claude Code · Cursor · Codex · Gemini CLI · Windsurf · GitHub Copilot CLI**
  188. Every skill file is a plain markdown doc with a YAML header. Nothing agent-specific inside the body. If your agent reads `.claude/skills/`, `~/.claude/skills/`, or a `SKILL.md` file, loopkit fits.
  189. The bundled harness (`settings.json`, hooks, verifier subagent) is Claude-Code-shaped. Cursor/Codex/Gemini users can ignore the harness and use just the skills — or port the three harness files (they're small).
  190. ---
  191. ## vs other skill packs
  192. | | loopkit | [obra/superpowers](https://github.com/obra/superpowers) | [mattpocock/skills](https://github.com/mattpocock/skills) | [addyosmani/agent-skills](https://github.com/addyosmani/agent-skills) |
  193. |---|---|---|---|---|
  194. | Ships a harness (settings, verifier, loop runner) | **yes** | no | no | no |
  195. | Skills load only on trigger (YAML frontmatter) | yes | yes | yes | yes |
  196. | Methodology commitment required | **none** | Prime Radiant | GSD-adjacent | 6-phase lifecycle |
  197. | Skill count | 49 | ~40 | ~19 | ~24 |
  198. | Compatible with non-Claude agents | yes | Claude-first | multi | multi |
  199. | Install size | tiny | medium | medium | medium |
  200. Full breakdown: [docs/vs-others.md](./docs/vs-others.md).
  201. ---
  202. ## Positioning
  203. loopkit is deliberately not a methodology. Approaches like BMAD, Spec-Kit, and full lifecycle skill packs try to help by owning the process — but they take away the control that makes agents useful in your codebase. loopkit gives you the mini-skills and a floor to stand on. Everything else is yours to shape.
  204. The two failure modes long-running agents actually hit (doing too much at once; premature victory) are structural, not skill-shaped. `run.sh` + the verifier subagent are the structural answer. The skills just make each turn cheaper. The new **loop & harness** track (planner-spec-expand, sprint-contract, evaluator-calibration, harness-stripping, and friends) operationalizes the multi-session discipline described in the companion article.
  205. ---
  206. ## Contributing
  207. PRs welcome. The bar:
  208. 1. **Skills stay small.** One page, one trigger, one purpose. If it needs 200 lines it belongs in `docs/checklists/`.
  209. 2. **Every skill has YAML frontmatter** — `name`, `description`. Nothing else is required; nothing else should be added without a reason.
  210. 3. **No new methodologies.** loopkit doesn't ship lifecycles, phases, or ceremonies. Add a skill, not a framework.
  211. 4. **Match the existing file when editing.** Read it before you write.
  212. Adding a skill:
  213. ```bash
  214. # 1. copy the template (once available in template/SKILL.md)
  215. cp template/SKILL.md skills/my-new-skill/SKILL.md
  216. # 2. write it
  217. $EDITOR skills/my-new-skill/SKILL.md
  218. # 3. validate the frontmatter shape
  219. ./scripts/validate-skills
  220. # 4. open a PR
  221. ```
  222. Full contribution guide: [CONTRIBUTING.md](./CONTRIBUTING.md).
  223. ---
  224. ## License
  225. MIT. Built to be forked. Follow the build: [@archive on X](https://x.com/archive) · article: *Loop and Harness engineering*.
install.sh · Bundled script · 143 lines · 1 finding marked
  1. #!/usr/bin/env bash
  2. # claude-loopkit installer
  3. #
  4. # curl -fsSL https://raw.githubusercontent.com/Archive228/loopkit/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 4 on GitHub
  5. #
  6. # Env vars:
  7. # FORCE=1 overwrite existing files (default: skip)
  8. # BACKUP=1 snapshot existing .claude/ to .claude.bak-<ts>/ first
  9. # DEST=/path install target (default: $PWD)
  10. # LOOPKIT_REF=<ref> branch/tag to install from (default: main)
  11. # LOOPKIT_REPO=<r> override source repo (default: Archive228/loopkit)
  12. # QUIET=1 silence per-file logging (still prints summary)
  13. set -euo pipefail
  14. REPO="${LOOPKIT_REPO:-Archive228/loopkit}"
  15. REF="${LOOPKIT_REF:-main}"
  16. DEST="${DEST:-$PWD}"
  17. FORCE="${FORCE:-0}"
  18. BACKUP="${BACKUP:-0}"
  19. QUIET="${QUIET:-0}"
  20. # --- pretty printing (falls back to plain on non-tty) --------------------------
  21. if [ -t 1 ] && [ -z "${NO_COLOR:-}" ]; then
  22. C_DIM=$'\033[2m'; C_BOLD=$'\033[1m'; C_GREEN=$'\033[32m'
  23. C_YELLOW=$'\033[33m'; C_RED=$'\033[31m'; C_CYAN=$'\033[36m'; C_RESET=$'\033[0m'
  24. else
  25. C_DIM=""; C_BOLD=""; C_GREEN=""; C_YELLOW=""; C_RED=""; C_CYAN=""; C_RESET=""
  26. fi
  27. say() { printf "%s\n" "$*"; }
  28. step() { printf "${C_CYAN}==>${C_RESET} ${C_BOLD}%s${C_RESET}\n" "$*"; }
  29. ok() { printf " ${C_GREEN}✓${C_RESET} %s\n" "$*"; }
  30. skip() { [ "$QUIET" = "1" ] || printf " ${C_DIM}·${C_RESET} ${C_DIM}%s${C_RESET}\n" "$*"; }
  31. warn() { printf " ${C_YELLOW}!${C_RESET} %s\n" "$*"; }
  32. fail() { printf "${C_RED}xx${C_RESET} ${C_BOLD}%s${C_RESET}\n" "$*" >&2; }
  33. # --- preflight ----------------------------------------------------------------
  34. step "claude-loopkit installer"
  35. say " repo : ${C_BOLD}${REPO}${C_RESET}@${REF}"
  36. say " dest : ${C_BOLD}${DEST}${C_RESET}"
  37. say " mode : $([ "$FORCE" = "1" ] && echo overwrite || echo "skip-existing")$([ "$BACKUP" = "1" ] && echo " + backup" || echo "")"
  38. say ""
  39. for cmd in curl tar mktemp find; do
  40. if ! command -v "$cmd" >/dev/null 2>&1; then
  41. fail "required command not found: $cmd"
  42. exit 1
  43. fi
  44. done
  45. if [ ! -d "$DEST" ]; then
  46. fail "DEST does not exist: $DEST"
  47. exit 1
  48. fi
  49. # --- backup existing .claude if requested -------------------------------------
  50. if [ "$BACKUP" = "1" ] && [ -e "$DEST/.claude" ]; then
  51. ts=$(date +%Y%m%d-%H%M%S)
  52. bak="$DEST/.claude.bak-$ts"
  53. step "backing up existing .claude/"
  54. cp -R "$DEST/.claude" "$bak"
  55. ok "backup written to $bak"
  56. say ""
  57. fi
  58. # --- download tarball ---------------------------------------------------------
  59. step "downloading loopkit"
  60. TMP=$(mktemp -d)
  61. trap 'rm -rf "$TMP"' EXIT
  62. if ! curl -fsSL "https://codeload.github.com/$REPO/tar.gz/refs/heads/$REF" \
  63. | tar -xz --strip-components=1 -C "$TMP"; then
  64. fail "download failed — check network and that $REPO@$REF exists"
  65. exit 1
  66. fi
  67. ok "extracted to $TMP"
  68. say ""
  69. # --- copy loop ----------------------------------------------------------------
  70. wrote=0
  71. skipped=0
  72. copy_file() {
  73. src=$1
  74. dst=$2
  75. rel=${dst#"$DEST/"}
  76. if [ -e "$dst" ] && [ "$FORCE" != "1" ]; then
  77. skip "keep $rel"
  78. skipped=$((skipped + 1))
  79. return
  80. fi
  81. mkdir -p "$(dirname "$dst")"
  82. cp "$src" "$dst"
  83. case "$src" in *.sh) chmod +x "$dst" ;; esac
  84. [ "$QUIET" = "1" ] || ok "write $rel"
  85. wrote=$((wrote + 1))
  86. }
  87. copy_tree() {
  88. src_root=$1
  89. dst_root=$2
  90. [ -d "$src_root" ] || return 0
  91. while IFS= read -r f; do
  92. rel=${f#"$src_root"/}
  93. copy_file "$f" "$dst_root/$rel"
  94. done < <(find "$src_root" -type f)
  95. }
  96. step "installing files"
  97. copy_tree "$TMP/.claude" "$DEST/.claude"
  98. copy_tree "$TMP/skills" "$DEST/.claude/skills"
  99. for f in .mcp.json MEMORY.md run.sh AGENTS.md; do
  100. [ -f "$TMP/$f" ] && copy_file "$TMP/$f" "$DEST/$f"
  101. done
  102. say ""
  103. # --- summary ------------------------------------------------------------------
  104. step "summary"
  105. ok "$wrote files written"
  106. if [ "$skipped" -gt 0 ]; then
  107. warn "$skipped files kept (re-run with FORCE=1 to overwrite)"
  108. fi
  109. say ""
  110. # --- verify claude cli --------------------------------------------------------
  111. step "verifying claude CLI"
  112. if command -v claude >/dev/null 2>&1; then
  113. claude_ver=$(claude --version 2>/dev/null | head -n1 || echo "unknown")
  114. ok "claude found: $claude_ver"
  115. else
  116. warn "claude CLI not on PATH — skills will still work in Cursor/Codex/Gemini"
  117. warn "install Claude Code: https://claude.ai/download"
  118. fi
  119. say ""
  120. # --- next steps ---------------------------------------------------------------
  121. step "next"
  122. say " 1. ${C_BOLD}cd $DEST${C_RESET}"
  123. say " 2. open your agent (claude, cursor, codex, gemini)"
  124. say " 3. write a spec: ${C_DIM}echo 'STATUS: not-started' > IMPLEMENTATION_PLAN.md${C_RESET}"
  125. say " 4. drive the loop: ${C_DIM}./run.sh${C_RESET}"
  126. say ""
  127. say " full 41-skill list + docs: ${C_CYAN}https://github.com/$REPO${C_RESET}"

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.