Agent skill

Spec Lite Chorus

by Chorus-AIDLC in Chorus-AIDLC/Chorus

Lightweight, Chorus-native local specs for Chorus PM workflows on dsh — a durable local spec .chorus/specs/<slug/spec.md (one per capability/feature) edited in place and NEVER synced (git history is…

AGPL-3.0Auto-check passedProduct & Project Management

Install Spec Lite Chorus

skills CLI
$ npx skills add Chorus-AIDLC/Chorus --skill spec-lite-chorus -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Chorus-AIDLC/Chorus spec-lite-chorus --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Chorus-AIDLC/Chorus.git skills-src && mkdir -p .claude/skills && cp -r skills-src/packages/chorus-dsh/skills/spec-lite-chorus .claude/skills/spec-lite-chorus && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
spec-lite-chorus
GitHub stars
1.2k
Token cost
~2.4k tokens
SKILL.md length
1,033 words
Files
1
Skills in repo
64
Repo updated
First seen
Licence
AGPL-3.0

At a glance

Lightweight, Chorus-native local specs for Chorus PM workflows on dsh — a durable local spec .chorus/specs/<slug/spec.md (one per capability/feature) edited in place and NEVER synced (git history is…

  • Works in 6 steps: Confirm mode = lite (else no-op). → Create the dated folder /-/ and write… → Update /spec.md in place to the new… → …
  • Tasks that involve Git workflow
  • SKILL.md covers Mode (how you got here), The durable local spec —…, Per-change dated folders — /-/ and Flow (one change), plus 2 more sections
  • Calls git

What it does

Spec Lite Chorus is an agent skill from Chorus-AIDLC/Chorus. Lightweight, Chorus-native local specs for Chorus PM workflows on dsh — a durable local spec .chorus/specs/<slug/spec.md (one per capability/feature) edited in place and NEVER synced (git history is its record), plus one dated folder per change effort .chorus/specs/<slug/<YYYY-MM-DD-<change-slug/ holding Chorus-typed docs (prd.md, techdesign.md, …) that ARE mirrored 1:1 into persistent Chorus Documents via --arg-file. The fallback when OpenSpec isn't in use; a low-token alternative to the heavier…

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Product & Project Management, covering Git workflow, Computer vision and PRD writing. It works with Model Context Protocol. The repository describes itself as: The Agent Harness for AI-Human Collaboration, inspired by the AI-DLC (AI-Driven Development Lifecycle). The licence is AGPL-3.0.

When your agent uses it

  • Tasks that involve Git workflow
  • Tasks that involve Computer vision
  • Tasks that involve PRD writing

Example prompts

  • “/spec-lite-chorus”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Confirm mode = lite (else no-op).
  2. Create the dated folder /-/ and write its synced change docs —
  3. Update /spec.md in place to the new cumulative truth (Requirements, acceptance points,
  4. Create the proposal container with one literal locator line in description (own line, no trailing
  5. Mirror the dated folder's docs to Chorus (below). Add tasks via chorus_pm_add_task_draft —
  6. Develop → keep editing spec.md + the change docs, re-mirroring the change docs as work lands and

What it can do on your machine

Read from SKILL.md and the folder at commit 37d62d9. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Spec Lite Chorus loads about 2.4k tokens when it runs. Until then it costs about 158 tokens; SKILL.md has 1,033 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~158
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Chorus-AIDLC/Chorus at commit 37d62d9, republished under its AGPL-3.0 licence (© Chorus-AIDLC). 1,033 words, ~2,396 tokens.

Download SKILL.mdSave it as .claude/skills/spec-lite-chorus/SKILL.md (or your agent's skills folder).
name
spec-lite-chorus
description
Lightweight, Chorus-native local specs for Chorus PM workflows on dsh — a durable local spec `.chorus/specs/<slug>/spec.md` (one per capability/feature) edited in place and NEVER synced (git history is its record), plus one dated folder per change effort `.chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/` holding Chorus-typed docs (prd.md, tech_design.md, …) that ARE mirrored 1:1 into persistent Chorus Documents via `--arg-file`. The fallback when OpenSpec isn't in use; a low-token alternative to the heavier openspec-aware-chorus path. Read from proposal / develop / yolo when the spec mode resolves to `lite`.
license
AGPL-3.0
metadata.author
chorus
metadata.version
0.22.1
metadata.category
project-management
metadata.mcp_server
chorus

spec-lite — durable local spec + per-change synced docs (dsh plugin)

A shared sub-procedure for the Chorus stage skills (proposal-chorus, develop-chorus, yolo-chorus) — the lightweight spec mode, modelled on superpowers (a durable spec that lives on, plus per-effort artifacts): one durable local spec per capability (<slug>/spec.md, edited in place, never synced — git history is its 留痕), plus one dated folder per change effort (<slug>/<YYYY-MM-DD>-<change-slug>/ of Chorus-typed docs — prd.md, … — that are mirrored 1:1 into persistent Chorus Documents). No new CLI, MCP tool, backend, or schema — mirroring reuses the existing document tools.

Tool namespace: Chorus MCP tools are exposed under a mcp__chorus__ prefix on dsh — prepend it when invoking the MCP tools directly (see chorus). Document-mirror calls do NOT go through the MCP harness — they go through the chorus CLI (chorus mcp call, preferred) or the package-local chorus-mcp-call.mjs wrapper resolved into $CHORUS_MCP_CALL (fallback), which talk to the Chorus MCP endpoint over HTTP with your API key. See openspec-aware-chorus §2 / §3.6 for the exact contract (same transport, same halt-on-error helper).

Mode (how you got here)

The spec mode is computed by the chorus-dsh bundle at plugin load (resolveSpecMode, the TS mirror of the canonical bash resolver), not by you — the bundle publishes it as the CHORUS_SPEC_MODE environment variable and injects a ## Spec Mode section into your first-step context stating the resolved value. You are here because it resolved to lite; if ## Spec Mode (or CHORUS_SPEC_MODE) says anything else, this skill is a no-op — return to the caller. (For the record, the rule: an explicit CHORUS_SPEC_MODE wins, else OpenSpec when usable, else lite.)

The durable local spec — <slug>/spec.md

.chorus/specs/<slug>/spec.md — <slug> (kebab-case) names a capability/feature, not one change. This is the single, cumulative, human-readable "current truth" of the capability: edited in place by every change, never mirrored to Chorus, carries no Chorus ids. Minimal frontmatter only (slug, title, status: draft|active|done, created), then plain prose — ## Intent, ## Requirements (prose + - [ ] acceptance points, no SHALL/scenario grammar), ## Non-goals. Start from the inline durable spec.md template below. Its git history is the whole record — no changelog section, no Chorus round-trip. This file NEVER enters the mirror loop.

status describes the capability, not a single change: active while any change is in flight, done when the current change delivers and none is open. A new change against a done capability reopens it to active, back to done on delivery.

Template — the durable spec.md
markdown
---
slug: <kebab-case-capability>
title: <Capability title>
status: draft            # draft | active | done
created: <YYYY-MM-DD>
---

## Intent
<what this capability is for, in prose>

## Requirements
<prose, no SHALL/scenario grammar>
- [ ] <acceptance point>

## Non-goals
- <explicitly out of scope>

Per-change dated folders — <slug>/<YYYY-MM-DD>-<change-slug>/

Each change effort is one dated folder directly under <slug>/ (no changes/ wrapper), e.g. .chorus/specs/<slug>/2026-09-08-add-export/. Date + slug so same-day changes don't collide and folders sort by date. It holds the Chorus-typed docs for THAT change — one file per Document type:

FileDocument.typeRequired?
prd.mdprdyes — the primary per-change doc
tech_design.mdtech_designoptional — the "how"
adr.md / guide.md / spec.mdadr / guide / specoptional

These files ARE synced — each maps to one persistent Chorus Document of its type. Their frontmatter carries the sync ids proposalUuid and documentUuid (the type is implied by the filename). Start from the inline dated-folder document template below. A different change to the same capability is a different dated folder. The current change's folder is edited and re-mirrored throughout its effort (until delivery); only previously-delivered dated folders are left frozen — you don't reach back and rewrite a past change.

Two files named spec.md, different roles. The durable <slug>/spec.md (local only, no ids) is NOT the same as a per-change spec-type doc, which would live at <slug>/<date>-<slug>/spec.md (synced, carries ids). Prefer prd.md as the per-change primary doc to avoid the confusion.

Template — a dated-folder document

The document type is implied by the filename (prd.md → prd, tech_design.md → tech_design, …), NOT a frontmatter key.

markdown
---
title: <Document title as it appears in Chorus>
proposalUuid: <uuid>      # written on first mirror
documentUuid:             # empty until the draft materializes on approval
---

# <Document title>
<body — this file's bytes are the source of truth for the Chorus Document>
Show full SKILL.md (439 more words)Show less

Flow (one change)

  1. Confirm mode = lite (else no-op).
  2. Create the dated folder <slug>/<YYYY-MM-DD>-<change-slug>/ and write its synced change docs — prd.md (required), tech_design.md etc. only if warranted (use the dated-folder document template above).
  3. Update <slug>/spec.md in place to the new cumulative truth (Requirements, acceptance points, status) — local only, no sync.
  4. Create the proposal container with one literal locator line in description (own line, no trailing punctuation) so develop finds the change: Spec-lite: .chorus/specs/<slug>/<YYYY-MM-DD>-<change-slug>/
  5. Mirror the dated folder's docs to Chorus (below). Add tasks via chorus_pm_add_task_draft — no tasks.md, no CLI / validate / archive, no delta grammar. Tasks live in Chorus.
  6. Develop → keep editing spec.md + the change docs, re-mirroring the change docs as work lands and ticking acceptance points. On delivery set the durable spec.md status: done.

Mirror — only the dated-folder docs (never spec.md)

Every dated-folder <type>.md maps to one persistent Chorus Document of that type, tracked by documentUuid in the file's frontmatter. Fill content from the file's bytes with --arg-file — never re-type the body (drifts, burns ~20k tokens). One call per file; resolve identity by documentUuid / (proposalUuid, type), never by title alone (a lookup finding zero or >1 MUST halt). Guard every call with the chorus_check_response halt-on-error helper (openspec-aware-chorus §6). No chorus on PATH? Fall back to the package-local chorus-mcp-call.mjs wrapper (resolved into $CHORUS_MCP_CALL at plugin load) + json_encode_file (openspec-aware-chorus §3.6). <slug>/spec.md is NEVER in this loop.

  • First time a doc is authored (its dated folder is new): write proposalUuid into frontmatter, mirror into a proposal draft — chorus mcp call chorus_pm_add_document_draft "{\"proposalUuid\":\"$P\",\"type\":\"prd\",\"title\":\"PRD: $TITLE\"}" --arg-file content=".chorus/specs/$SLUG/$DATED/prd.md". Edit the draft via chorus_pm_update_document_draft (returned draftUuid) before approval. On approval it materializes into a persistent Document — resolve by (proposalUuid, type) via chorus_get_documents, record documentUuid in frontmatter, re-mirror once so local == Chorus.
  • Later edits (a doc that already has a documentUuid): edit the file, then chorus mcp call chorus_pm_update_document "{\"documentUuid\":\"$D\"}" --arg-file content=".chorus/specs/$SLUG/$DATED/<type>.md". Each update auto-increments the Document version — that version history is the change doc's record in Chorus, alongside git.

Fallback shape (no chorus on PATH) — build $PAYLOAD with json_encode_file and call "$CHORUS_MCP_CALL" chorus_pm_update_document "$PAYLOAD", then chorus_check_response (see openspec-aware-chorus §3.6–§3.8 for the exact fallback blocks).

留痕: git history + Document versions

git log -- .chorus/specs/$SLUG/ is the audit trail — the durable spec.md's in-place diffs plus each dated folder's change docs; the mirrored Documents' auto-incremented versions are the parallel record in Chorus. No changelog section to maintain. Only .chorus/specs/ is version-controlled (.chorus/* + !.chorus/specs/).

Single-writer: the folder is shared — in a multi-task wave only the orchestrator / main agent edits + re-mirrors; parallel workers report via chorus_report_work only, re-reading before any write. Task state lives in Chorus, not the docs — the - [ ] points are acceptance intent, not a tracker.

© Chorus-AIDLC, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in packages/chorus-dsh/skills/spec-lite-chorus of Chorus-AIDLC/Chorus.

Open the folder on GitHubat commit 37d62d9

Compare with similar skills

Spec Lite Chorus next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Spec Lite Chorus compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Spec Lite Chorus this skillChorus-AIDLC/Chorus1.2k—~2.4kAutomated safety check: PassAGPL-3.0
Build MvpBuildGreatProducts/builder-os228—~1.2kAutomated safety check: NotesMIT
Ouroboros PM InterviewQ00/ouroboros6.2k—~5.7kAutomated safety check: PassMIT
PlaidBuildGreatProducts/plaid218—~1.6kAutomated safety check: PassMIT
Produck Feedback To Buildtryproduck/produck-skills511—~1kAutomated safety check: PassApache-2.0
Schematicblader/schematic241—~2.2kAutomated safety check: PassMIT

Similar skills

  • Build Mvp

    BuildGreatProducts/builder-os

    Use inside a product repository when the user wants the full MVP built from their BuilderOS spec documents.

    228 GitHub stars~1.2k tokensUpdated 3 mo ago
    Product & Project ManagementAuto-check: notes
  • Runs a guided product-manager interview that classifies each question automatically and produces a Product Requirements Document.

    6.2k GitHub stars~5.7k tokensUpdated 3 days ago
    Product & Project ManagementAuto-check passed
  • Plaid

    BuildGreatProducts/plaid

    Product Led AI Development — guides founders from idea to launched product.

    218 GitHub stars~1.6k tokensUpdated 5 mo ago
    Product & Project ManagementAuto-check passed
  • Produck Feedback To Build

    tryproduck/produck-skills

    Pulls full in-context user feedback tickets through the Produck MCP server and turns them into an aligned product change instead of a guess.

    511 GitHub stars~1k tokensUpdated 1 mo ago
    Product & Project ManagementAuto-check passed
  • Schematic

    blader/schematic

    Reverse engineer a detailed product and technical specification document from a git branch's implementation.

    241 GitHub stars~2.2k tokensUpdated 7 mo ago
    Product & Project ManagementAuto-check passed
  • Rhesis

    rhesis-ai/rhesis

    Design, run, and analyze AI test suites on Rhesis — explore endpoints, build test foundations from a spec, create requirements and metrics, execute tests, and analyze results.

    397 GitHub stars~1.2k tokensUpdated 2 days ago
    Product & Project ManagementAuto-check passed

More from Chorus-AIDLC/Chorus

All 64 skills in this repo
  • E2E Verification

    Chorus-AIDLC/Chorus

    A skill your agent uses when manually verifying a Chorus frontend change in a real browser — finding local login credentials, driving the running dev server with the Playwright MCP, logging in…

    1.2k GitHub stars~1.5k tokensUpdated yesterday
    Auto-check: notes
  • Blog

    Chorus-AIDLC/Chorus

    Write release blog posts for Chorus — problem-first narrative, bilingual (zh/en), following the project's editorial style.

    1.2k GitHub stars~1.2k tokensUpdated yesterday
    Auto-check passed
  • Brainstorm

    Chorus-AIDLC/Chorus

    Optional divergent-then-convergent dialogue for fuzzy ideas on Hermes.

    1.2k GitHub stars~3.6k tokensUpdated yesterday
    Auto-check passed
  • Brainstorm

    Chorus-AIDLC/Chorus

    Optional divergent-then-convergent dialogue for fuzzy ideas.

    1.2k GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • Brainstorm Chorus

    Chorus-AIDLC/Chorus

    Optional divergent-then-convergent dialogue for fuzzy ideas.

    1.2k GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • Chorus Brainstorm

    Chorus-AIDLC/Chorus

    Optional divergent-then-convergent dialogue for fuzzy ideas.

    1.2k GitHub stars~2.3k tokensUpdated yesterday
    Auto-check passed

Questions about Spec Lite Chorus

What does Spec Lite Chorus do?

Lightweight, Chorus-native local specs for Chorus PM workflows on dsh — a durable local spec .chorus/specs/<slug/spec.md (one per capability/feature) edited in place and NEVER synced (git history is…. Spec Lite Chorus is an agent skill from Chorus-AIDLC/Chorus.md, …) that ARE mirrored 1:1 into persistent Chorus Documents via --arg-file.

When should I use Spec Lite Chorus?

Spec Lite Chorus fits situations like: tasks that involve Git workflow; tasks that involve Computer vision; tasks that involve PRD writing.

How do I install Spec Lite Chorus in Claude Code?

Run `npx skills add Chorus-AIDLC/Chorus --skill spec-lite-chorus -a claude-code`. Or copy the skill folder (packages/chorus-dsh/skills/spec-lite-chorus in Chorus-AIDLC/Chorus) into .claude/skills/spec-lite-chorus in your project. Claude Code loads it when a task matches its description.

How do I install Spec Lite Chorus in Codex?

Run `npx skills add Chorus-AIDLC/Chorus --skill spec-lite-chorus -a codex`. Or copy the skill folder (packages/chorus-dsh/skills/spec-lite-chorus in Chorus-AIDLC/Chorus) into .agents/skills/spec-lite-chorus in your project. Codex loads it when a task matches its description.

Can I use Spec Lite Chorus in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Chorus-AIDLC/Chorus --skill spec-lite-chorus -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/spec-lite-chorus, .gemini/skills/spec-lite-chorus, .github/skills/spec-lite-chorus and .opencode/skills/spec-lite-chorus in your project.

What does Spec Lite Chorus need to run?

Going by SKILL.md and its folder, Spec Lite Chorus needs the command-line tools its instructions call (git).

Does Spec Lite Chorus access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Spec Lite Chorus safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Spec Lite Chorus use?

Spec Lite Chorus is published under the AGPL-3.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Spec Lite Chorus use?

About 2.4k tokens (SKILL.md is roughly 9.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Spec Lite Chorus?

Skills that share tags, products or a category with Spec Lite Chorus: Build Mvp (BuildGreatProducts/builder-os, 228 stars), Ouroboros PM Interview (Q00/ouroboros, 6.2k stars), Plaid (BuildGreatProducts/plaid, 218 stars) and Produck Feedback To Build (tryproduck/produck-skills, 511 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Spec Lite Chorus?

Chorus-AIDLC (a GitHub organization) maintains it in Chorus-AIDLC/Chorus, which has 1,192 GitHub stars. The repository holds 64 skills in this directory. The repository was last updated on October 9, 2026.

Source: Chorus-AIDLC/Chorus on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.