coder-xieshijie/dev-skills / skills/repo-readiness/assets/verify-skill
verify-<app>
FlaggedStarts isolated <app> instances, drives them through <entry points> and reports one result per sub-feature and entry with evidence. Use when verifying a change, reproducing a bug, or running, writing or checking feature maps and their scenario scripts.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 6.7 KB |
| features/README.md | markdown | 1.4 KB |
| references/maps.md | markdown | 11.4 KB |
| scripts/config.mjs | script | 5.2 KB |
| scripts/contract.mjs | script | 16.6 KB |
| scripts/map-check.mjs | script | 22.2 KB |
| scripts/primitives.mjs | script | 7.2 KB |
| scripts/runner.mjs | script | 24.0 KB |
| scripts/test/contract-check.test.mjs | script | 3.7 KB |
| scripts/test/contract.test.mjs | script | 1.4 KB |
| scripts/test/fixture/notes-entry.mjs | script | 3.5 KB |
| scripts/test/fixture/proc-app.mjs | script | 1.3 KB |
| scripts/test/fixture/proc-entry.mjs | script | 5.5 KB |
| scripts/test/fixture/web-entry.mjs | script | 535 B |
| scripts/test/helpers.mjs | script | 5.0 KB |
| scripts/test/map-check.test.mjs | script | 9.5 KB |
| scripts/test/primitives.test.mjs | script | 4.1 KB |
| scripts/test/runner.test.mjs | script | 17.3 KB |
| scripts/verify.mjs | script | 9.7 KB |
| verify.config.json | config | 1016 B |
scripts/map-check.mjs
View on GitHub// `check`: read-only structural check of the feature maps, in the format references/maps.md defines.
// index - the maps the index links and the feature-map/*.md files under mapRoots match one to one;
// id - sub-feature ids `<map>.<short>` are unique across maps and start with their map name;
// criteria - each criterion `- \`<sub-feature>#<n>\` <expected>` sits under `### <entry>` of the
// steps section (list items in other sections are not criteria); ids are unique; every
// driven entry a sub-feature declares has criteria;
// look criteria sit only under entries the config marks `"ui": true`;
// scenario - every scripted entry has scenarios/<id>.<slug>.mjs; each script checks every criterion
// of its sub-feature at that entry exactly once (t.criterion / t.confirm, t.look for look
// criteria, id as a literal) and no other id;
// script - scripts and shared steps leave reading, waiting and process control to the runner and
// the primitives; shared steps check no criteria;
// spec - every requirement id a spec defines (headings) is referenced by a sub-feature of the
// maps on that spec or named in their uncovered section; referenced ids exist;
// uncovered - each map has the uncovered section;
// status - no run results in a map or in the verification Skill (SKILL.md, references/, the
// index): no run-record heading in a map, and no line that ties a result word (PASS,
// FAIL, BLOCKED, UNVERIFIED, TO-CONFIRM, standing alone: not FAILED, not in a code span
// or quotes) to a date, a commit or a count. Result words alone are allowed: they also
// name expected results and how a script judges.
// Warnings (they do not fail the check): a tool scripts call as t.<name> or maps drive with `do <name>`
// that the verification Skill (SKILL.md, references/) never names, so an agent cannot look it up; and
// an AGENTS.md or CLAUDE.md at the repository root that does not name the verification Skill.
// It does not check that the map matches the product; only running it does.
import { existsSync, readdirSync, readFileSync } from 'node:fs';
import path from 'node:path';
const ITEM_RE = /^- `([a-z0-9-]+)\.([a-z0-9-]+)`\s*[((]([^))]*)[))]/;
const CRITERION_RE = /^(\s*)- `([a-z0-9-]+\.[a-z0-9-]+)#(\d+)`(\s*\S)?/;
const SCENARIO_RE = /^([a-z0-9-]+\.[a-z0-9-]+)\.([a-z0-9-]+)\.mjs$/;
const CHECK_RE = /\bt\.(criterion|confirm|look)\(\s*(['"])([^'"`$]+)\2/g;
const NON_LITERAL_CHECK_RE = /\bt\.(?:criterion|confirm|look)\((?!\s*['"][^'"`$]+['"])/g;
const SCRIPT_RULES = [
[
/\b(readFileSync|existsSync|readdirSync|statSync|readFile|readdir|createReadStream|node:fs)\b/,
(m) => `${m[1]}: read evidence through t (the adapter's strict reads), not the file system`,
],
[
/\b(spawn|spawnSync|exec|execSync|execFile|execFileSync|node:child_process)\b/,
(m) => `${m[1]}: instances are started and stopped by the runner; drive through t`,
],
[/\bsetTimeout\s*\(|\bsetInterval\s*\(/, () => 'a timer: wait with t.until, t.hold or t.observe'],
[/\bfrom\s+['"]\.\.\//, () => "an import outside this map's scenarios dir"],
];
// A result word standing alone (not FAILED, not `BLOCKED` or "PASS"), and what ties it to a run.
const RESULT = '(?:PASS|FAIL|BLOCKED|UNVERIFIED|TO-CONFIRM)';
const BARE_RESULT_RE = new RegExp(`(?<![\\w\`'"-])${RESULT}(?![\\w\`'"-])`);
const DATE_RE = /\b\d{4}-\d{2}-\d{2}\b/;
const COUNT_RE = new RegExp(`\\b\\d+\\s*(?:×\\s*)?${RESULT}(?![\\w-])|(?<![\\w-])${RESULT}\\s*[:=×]\\s*\\d+\\b`);
const NAMED_COMMIT_RE = /\b(?:commit|head|base|sha)[\s:=@]+`?[0-9a-f]{7,40}\b/i;
const COUNTS_JSON_RE = new RegExp(`"${RESULT}"\\s*:\\s*\\d`);
const isCommit = (cell) => /^[0-9a-f]{7,40}$/.test(cell) && /\d/.test(cell) && /[a-f]/.test(cell);
// Lines that record a run: a sentence (or table row) with a result word and a date, a count or a
// commit (a table cell that is a commit hash counts), or result counts as JSON; code spans (file
// names, product values) do not count. A Markdown paragraph is one line, so a date in one sentence
// and a result word in the next are not tied.
const recordsRun = (text) => {
const bare = text.replace(/`[^`]*`/g, '``');
if (!BARE_RESULT_RE.test(bare)) return false;
const cells = text.trim().startsWith('|') ? text.split('|').map((cell) => cell.trim().replace(/^`|`$/g, '')) : [];
return DATE_RE.test(bare) || COUNT_RE.test(bare) || NAMED_COMMIT_RE.test(text) || cells.some(isCommit);
};
export function runRecordLines(text) {
const found = [];
for (const [i, line] of text.split(/\r?\n/).entries()) {
const parts = line.trim().startsWith('|') ? [line] : line.split(/(?<=[。;!?])|(?<=[.;!?])\s+/);
if (COUNTS_JSON_RE.test(line) || parts.some(recordsRun)) found.push(i + 1);
}
return found;
}
const RUN_RECORD = 'a run result tied to a date, a commit or a count: results belong in the run\'s evidence directory and the MR description';
const splitList = (text) =>
text
.split(/[,、,]/)
.map((item) => item.trim())
.filter(Boolean);
function section(lines, heading) {
const start = lines.findIndex((line) => line.trim() === `## ${heading}`);
if (start < 0) return undefined;
const next = lines.findIndex((line, i) => i > start && line.startsWith('## '));
return [start, next < 0 ? lines.length : next];
}
export const scenariosDirOf = (mapFile) => path.join(path.dirname(mapFile), 'scenarios');
export function mapScenarios(mapFile, config) {
const dir = scenariosDirOf(mapFile);
const mapName = path.basename(mapFile, '.md');
if (!existsSync(dir)) return [];
return readdirSync(dir)
.filter((file) => file.endsWith('.mjs') && file.startsWith(`${mapName}.`))
.sort()
.map((file) => {
const match = SCENARIO_RE.exec(file);
const entry = match && config.entryList.find((item) => item.slug === match[2]);
return { file: path.join(dir, file), id: match?.[1] ?? null, entry: entry?.name ?? null };
});
}
export function parseMap(file, config) {
const { headings, lookMarker } = config;
const specId = new RegExp(config.specId, 'g');
const driven = Object.fromEntries(config.entryList.map((entry) => [`### ${entry.name}`, entry.name]));
const lines = readFileSync(file, 'utf8').split(/\r?\n/);
const problems = [];
const problem = (check, line, message) => problems.push({ check, line, message });
const subfeatures = [];
const sub = section(lines, headings.subfeatures);
if (!sub) problem('id', 0, `no "## ${headings.subfeatures}" section`);
for (let i = sub?.[0] ?? 0; sub && i < sub[1]; i += 1) {
if (!lines[i].startsWith('- ')) continue;
let item = lines[i];
for (let j = i + 1; j < sub[1] && /^\s{2,}\S/.test(lines[j]); j += 1) item += ` ${lines[j].trim()}`;
const match = ITEM_RE.exec(item);
if (!match) {
problem('id', i + 1, 'sub-feature item is not "- `<map>.<short>` (<spec ids>; <entry>, <entry>): ..."');
continue;
}
const parts = match[3].split(/[;;]/);
subfeatures.push({
id: `${match[1]}.${match[2]}`,
mapPart: match[1],
entries: splitList(parts.at(-1)),
refs: parts.slice(0, -1).flatMap((part) => part.match(specId) ?? []),
line: i + 1,
});
}
const criteria = [];
let inSteps = false;
let entry = null;
for (const [i, line] of lines.entries()) {
if (line.startsWith('## ')) {
inSteps = line.trim() === `## ${headings.steps}`;
entry = null;
} else if (line.startsWith('### ')) entry = inSteps ? (driven[line.trim()] ?? null) : null;
// Only the steps section holds criteria; an item elsewhere (Gotchas, Not covered) that starts
// with a criterion id refers to it.
if (!inSteps) continue;
const match = CRITERION_RE.exec(line);
if (!match) continue;
const id = `${match[2]}#${match[3]}`;
const next = lines[i + 1] ?? '';
if (!match[4] && !(next.trim() && next.search(/\S/) > match[1].length + 1)) {
problem('criteria', i + 1, `criterion ${id} has no expected result`);
continue;
}
if (!entry) {
problem('criteria', i + 1, `criterion ${id} is not under an entry heading of "## ${headings.steps}"`);
continue;
}
const rest = line.slice(line.indexOf('`', line.indexOf('`') + 1) + 1).trim();
const look = rest.startsWith(lookMarker) || (!match[4] && next.trim().startsWith(lookMarker));
if (look && !config.entryList.find((item) => item.name === entry)?.ui)
problem('criteria', i + 1, `${id}: a look criterion belongs under an entry marked "ui": true`);
criteria.push({ id, subfeature: match[2], entry, line: i + 1, look });
}
const uncovered = section(lines, headings.uncovered);
if (!uncovered) problem('uncovered', 0, `no "## ${headings.uncovered}" section (write "None" when none)`);
const uncoveredRefs = uncovered ? lines.slice(...uncovered).flatMap((line) => line.match(specId) ?? []) : [];
for (const [i, line] of lines.entries())
if (headings.runRecord.some((name) => line.trim() === `## ${name}`))
problem('status', i + 1, "run results belong in the run's report, not in the map");
for (const line of runRecordLines(lines.join('\n'))) problem('status', line, RUN_RECORD);
return { name: path.basename(file, '.md'), file, subfeatures, criteria, uncoveredRefs, problems };
}
export const criteriaOf = (map, id, entry) =>
map.criteria.filter((item) => item.subfeature === id && item.entry === entry).map((item) => item.id);
export const looksOf = (map, id, entry) =>
map.criteria.filter((item) => item.subfeature === id && item.entry === entry && item.look).map((item) => item.id);
export function scriptCriteria(text) {
const matches = [...text.matchAll(CHECK_RE)];
return {
ids: matches.filter((m) => m[1] !== 'look').map((m) => m[3]),
looks: matches.filter((m) => m[1] === 'look').map((m) => m[3]),
nonLiteral: [...text.matchAll(NON_LITERAL_CHECK_RE)].length,
};
}
export function scriptProblems(text, { shared = false } = {}) {
const problems = [];
for (const [i, line] of text.split('\n').entries()) {
if (/^\s*\/\//.test(line)) continue;
for (const [pattern, message] of SCRIPT_RULES) {
const match = pattern.exec(line);
if (match) problems.push({ line: i + 1, message: message(match) });
}
if (shared && /\bt\.(criterion|confirm|look)\(/.test(line))
problems.push({ line: i + 1, message: 'criteria are checked in the scenario script, not a shared step' });
}
return problems;
}
function walkMaps(dir, out = []) {
if (!existsSync(dir)) return out;
for (const item of readdirSync(dir, { withFileTypes: true })) {
if (item.name === 'node_modules' || item.name.startsWith('.')) continue;
const full = path.join(dir, item.name);
if (item.isDirectory()) walkMaps(full, out);
else if (item.name.endsWith('.md') && path.basename(dir) === 'feature-map') out.push(full);
}
return out;
}
// The maps the index links, the spec each row gives them, the entries each map scripts, the files on disk.
export function listMaps(config) {
const { indexPath } = config;
const linked = new Map();
const specOf = new Map();
const scriptedOf = new Map();
let column = -1;
const cells = (line) =>
line
.split('|')
.slice(1, -1)
.map((cell) => cell.trim());
for (const [i, line] of readFileSync(indexPath, 'utf8').split('\n').entries()) {
if (line.startsWith('|') && cells(line).includes(config.headings.scriptedColumn))
column = cells(line).indexOf(config.headings.scriptedColumn);
const links = [...line.matchAll(/\]\(([^)\s#]+\.md)\)/g)].map((m) => path.resolve(path.dirname(indexPath), m[1]));
const maps = links.filter((file) => path.basename(path.dirname(file)) === 'feature-map');
const specs = links.filter((file) => !maps.includes(file));
const scripted = column >= 0 ? splitList(cells(line)[column] ?? '') : [];
for (const file of maps) {
linked.set(file, i + 1);
if (specs.length) specOf.set(file, specs[0]);
const names = [...config.scripted, ...scripted]
.map((name) => config.entryList.find((entry) => entry.name === name || entry.slug === name)?.name)
.filter(Boolean);
scriptedOf.set(file, [...new Set(names)]);
}
}
const onDisk = config.mapRoots.flatMap((root) => walkMaps(path.resolve(config.root, root))).sort();
return { linked, specOf, scriptedOf, onDisk };
}
function specIds(file, config) {
const heading = new RegExp(config.specHeading);
return readFileSync(file, 'utf8')
.split('\n')
.flatMap((line) => heading.exec(line)?.[1] ?? []);
}
export function checkMaps(config) {
const { root, indexPath } = config;
const rel = (file) => path.relative(root, file);
const problems = [];
const add = (file, check, line, message) => problems.push({ file: rel(file), check, line, message });
const { linked, specOf, scriptedOf, onDisk } = listMaps(config);
for (const [file, line] of linked) if (!existsSync(file)) add(indexPath, 'index', line, `listed map ${rel(file)} does not exist`);
for (const file of onDisk) if (!linked.has(file)) add(file, 'index', 0, 'map file is not listed in the index');
const drivenNames = config.entryList.map((entry) => entry.name);
const maps = [...linked.keys()].filter(existsSync).map((file) => parseMap(file, config));
const seen = new Map();
const summary = [];
for (const map of maps) {
for (const { check, line, message } of map.problems) add(map.file, check, line, message);
if (seen.has(`map:${map.name}`)) add(map.file, 'id', 0, `map name ${map.name} is used twice`);
seen.set(`map:${map.name}`, map.file);
const scenarios = mapScenarios(map.file, config);
const scripted = scriptedOf.get(map.file) ?? [];
const criterionSeen = new Map();
for (const item of map.criteria) {
if (criterionSeen.has(item.id))
add(map.file, 'criteria', item.line, `${item.id} is used twice (line ${criterionSeen.get(item.id)})`);
criterionSeen.set(item.id, item.line);
const feature = map.subfeatures.find((f) => f.id === item.subfeature);
if (!feature) add(map.file, 'criteria', item.line, `${item.id}: ${item.subfeature} is not a declared sub-feature`);
else if (!feature.entries.includes(item.entry))
add(map.file, 'criteria', item.line, `${item.id} is under ${item.entry}, which ${item.subfeature} does not declare`);
}
for (const { id, mapPart, entries, line } of map.subfeatures) {
if (mapPart !== map.name) add(map.file, 'id', line, `${id} does not start with the map name ${map.name}`);
if (seen.has(id)) add(map.file, 'id', line, `${id} is already used in ${rel(seen.get(id))}`);
seen.set(id, map.file);
if (entries.length === 0) add(map.file, 'id', line, `${id} has no entry`);
for (const entry of entries) {
if (drivenNames.includes(entry) && criteriaOf(map, id, entry).length === 0)
add(map.file, 'criteria', line, `${id} / ${entry} has no criteria (\`${id}#<n>\` items under ### ${entry})`);
if (scripted.includes(entry) && !scenarios.some((s) => s.id === id && s.entry === entry)) {
const slug = config.entryList.find((e) => e.name === entry).slug;
add(map.file, 'scenario', line, `${id} / ${entry} has no scenario script scenarios/${id}.${slug}.mjs`);
}
}
}
const dir = scenariosDirOf(map.file);
const shared = existsSync(dir) ? readdirSync(dir).filter((file) => /^_.*\.mjs$/.test(file)) : [];
for (const file of shared)
for (const { line, message } of scriptProblems(readFileSync(path.join(dir, file), 'utf8'), { shared: true }))
add(path.join(dir, file), 'script', line, message);
for (const item of scenarios) {
const text = readFileSync(item.file, 'utf8');
for (const { line, message } of scriptProblems(text)) add(item.file, 'script', line, message);
const declared = map.subfeatures.some((f) => f.id === item.id && f.entries.includes(item.entry));
if (!item.id || !item.entry || !declared) {
add(item.file, 'scenario', 0, 'script name is not <declared id>.<entry slug>.mjs of a declared entry');
continue;
}
const expected = criteriaOf(map, item.id, item.entry);
const looks = looksOf(map, item.id, item.entry);
const checked = scriptCriteria(text);
if (checked.nonLiteral) add(item.file, 'scenario', 0, 't.criterion / t.confirm / t.look take the id as a string literal');
for (const cid of expected) {
const look = looks.includes(cid);
const count = (look ? checked.looks : checked.ids).filter((other) => other === cid).length;
if (count !== 1)
add(item.file, 'scenario', 0, `${cid} is ${look ? 'saved with t.look' : 'checked'} ${count} times; each criterion exactly once`);
if ((look ? checked.ids : checked.looks).includes(cid))
add(item.file, 'scenario', 0, look ? `${cid} is a look criterion: use t.look` : `${cid} is not a look criterion: use t.criterion or t.confirm`);
}
for (const cid of new Set([...checked.ids, ...checked.looks].filter((other) => !expected.includes(other))))
add(item.file, 'scenario', 0, `${cid} is not a ${item.entry} criterion of ${item.id} in the map`);
}
summary.push({
name: map.name,
file: rel(map.file),
subfeatures: map.subfeatures.length,
criteria: map.criteria.length,
scenarios: scenarios.length,
scripted,
});
}
const specs = [];
for (const spec of new Set(specOf.values())) {
const onSpec = maps.filter((map) => specOf.get(map.file) === spec);
if (!existsSync(spec)) {
add(indexPath, 'spec', linked.get(onSpec[0]?.file) ?? 0, `spec ${rel(spec)} does not exist`);
continue;
}
const ids = specIds(spec, config);
if (ids.length === 0)
add(
spec,
'spec',
0,
'no requirement id headings for the maps to reference; name a source without ids in the index as a code span, not a link',
);
const referenced = new Set(onSpec.flatMap((map) => map.subfeatures.flatMap((f) => f.refs)));
const uncovered = new Set(onSpec.flatMap((map) => map.uncoveredRefs));
const prefixes = new Set(ids.map((id) => id.replace(/-\d+$/, '')));
for (const map of onSpec)
for (const feature of map.subfeatures)
for (const ref of feature.refs)
if (prefixes.has(ref.replace(/-\d+$/, '')) && !ids.includes(ref))
add(map.file, 'spec', feature.line, `${feature.id} references ${ref}, which ${rel(spec)} does not define`);
for (const id of ids.filter((id) => !referenced.has(id) && !uncovered.has(id)))
add(spec, 'spec', 0, `${id} is referenced by no sub-feature and not named under "${config.headings.uncovered}"`);
specs.push({ spec: rel(spec), ids: ids.length, referenced: ids.filter((id) => referenced.has(id)).length });
}
for (const file of skillDocs(config)) for (const line of runRecordLines(readFileSync(file, 'utf8'))) add(file, 'status', line, RUN_RECORD);
const warnings = [
...undocumentedTools(config, maps).map(({ file, line, message }) => ({ file: rel(file), check: 'tools', line, message })),
...unlinkedAgentFiles(config).map(({ file, message }) => ({ file: rel(file), check: 'agents', line: 0, message })),
];
return { ok: problems.length === 0, index: rel(indexPath), maps: summary, specs, problems, warnings };
}
// The verification Skill's own documents: SKILL.md, references/*.md and the map index.
function skillDocs(config) {
const refs = path.join(config.skillDir, 'references');
return [
path.join(config.skillDir, 'SKILL.md'),
config.indexPath,
...(existsSync(refs) ? readdirSync(refs).filter((f) => f.endsWith('.md')).map((f) => path.join(refs, f)) : []),
].filter(existsSync);
}
// AGENTS.md and CLAUDE.md at the repository root that do not name the verification Skill's directory.
// A CLAUDE.md that imports AGENTS.md (`@AGENTS.md`) is judged by AGENTS.md alone.
function unlinkedAgentFiles(config) {
const name = path.basename(config.skillDir);
const text = (file) => (existsSync(path.join(config.root, file)) ? readFileSync(path.join(config.root, file), 'utf8') : null);
const agents = text('AGENTS.md');
const claude = text('CLAUDE.md');
const names = (content) => content.includes(name);
const out = [];
const message = (file) => `${file} does not name the verification Skill (${name}): an agent reading it will not find how to verify`;
if (agents !== null && !names(agents)) out.push({ file: path.join(config.root, 'AGENTS.md'), message: message('AGENTS.md') });
if (claude !== null && !names(claude) && !(/^@AGENTS\.md\b/m.test(claude) && agents !== null))
out.push({ file: path.join(config.root, 'CLAUDE.md'), message: message('CLAUDE.md') });
return out;
}
// t.<name> members the runner itself provides; every other one comes from an adapter's tools().
const RUNNER_MEMBERS = new Set(['id', 'entry', 'runDir', 'instance', 'until', 'hold', 'observe', 'select', 'precondition', 'criterion', 'confirm', 'look', 'unreadable', 'note', 'defer']);
function undocumentedTools(config, maps) {
const docs = [path.join(config.skillDir, 'SKILL.md')];
const refs = path.join(config.skillDir, 'references');
if (existsSync(refs)) docs.push(...readdirSync(refs).filter((f) => f.endsWith('.md')).map((f) => path.join(refs, f)));
if (!existsSync(docs[0])) return [];
const text = docs.filter(existsSync).map((file) => readFileSync(file, 'utf8')).join('\n');
const documented = (name) => new RegExp(`\`(?:t\\.)?${name}[\`(\\s]`).test(text);
const used = new Map();
const use = (name, file, line) => {
if (!RUNNER_MEMBERS.has(name) && !used.has(name)) used.set(name, { file, line });
};
for (const map of maps) {
for (const [i, line] of readFileSync(map.file, 'utf8').split('\n').entries())
for (const m of line.matchAll(/(?:\$V|verify\.mjs)\s+do\s+([A-Za-z_]\w*)/g)) use(m[1], map.file, i + 1);
const dir = scenariosDirOf(map.file);
if (!existsSync(dir)) continue;
for (const file of readdirSync(dir).filter((f) => f.endsWith('.mjs')))
for (const [i, line] of readFileSync(path.join(dir, file), 'utf8').split('\n').entries())
for (const m of line.matchAll(/\bt\.([A-Za-z_]\w*)\b/g)) use(m[1], path.join(dir, file), i + 1);
}
return [...used]
.filter(([name]) => !documented(name))
.map(([name, { file, line }]) => ({ file, line, message: `tool ${name} is used but the verification Skill never names it (\`${name}\`)` }));
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |