Author: TABARC-Code GitHub: TABARC-Code
Two skills that only make proper sense together.
skill-builder (v3.0.0) turns rough ideas into reusable, tested, classified, linked Claude skills. Six phases, two sidecars, one file loaded at a time.
video-workflow-extractor (v2.1.1) turns a narrated video into a graded procedure that skill-builder can safely build from. It exists because "safely" is doing real work in that sentence.
You can install either alone. They're better wired.
Large prompt and skill ecosystems rot. Not dramatically, which is the trouble. They rot the way a shed fills up: one reasonable decision at a time, until six weeks later there's a 4,000-line "universal framework" nobody wants to open, three files claiming authority over the same thing, and a relationship map that describes a network which stopped existing four commits ago.
The core idea is boring and it works:
Separate creativity from engineering.
Don't force one system to brainstorm wildly, structure outputs, validate logic, manage relationships, optimise triggers, benchmark behaviour, and maintain consistency, all in the same breath. It can't. It'll do all seven badly and sound confident about it.
So each phase does one job, hands over a defined packet, and isn't allowed to certify its own work.
Phase 0 Source Routing only when the input is a book, video, or transcript
Phase 1 Creative Exploration divergent. what should this skill be?
Phase 2 Handoff Bridge the airlock
Phase 3 Structured Engineering convergent. build exactly the contract
Phase 4 Skill Creator validate, test, gate, package
Phase 5 Kaizen Audit Loop improve. also where improvement work starts
Two sidecars sit beside the chain: relationship contracts, and Dewey-style classification.
The bridge at Phase 2 is the part people want to delete, and it's the part that matters most. Ideation certifying itself produces vapour. Engineering invading ideation produces timid, obvious skills. The airlock keeps both honest, and it costs about ninety seconds.
This is the newest bit, and the reason the second skill exists.
Sources aren't interchangeable. A book gives you edited, deliberate prose that sat still while someone thought about it. A video transcript gives you speech. Disfluent, deictic, full of "and then you just click that one there", with the genuinely important step occasionally performed in complete silence while the narrator says "like this".
Feed both into the same ideation step as equal evidence and you get a skill that states invented steps in exactly the same confident register as real ones. Nobody reading it can tell which sentences came from the source and which the extractor made up, because they're written identically. That's the failure, and it's quiet.
So narration gets treated as testimony, not evidence. Every reconstructed step is graded:
- Verified > the narrator said it, quote attached
- Inferred > reasonable from context, marked as an inference, with what would upgrade it
- Gap > missing, and you're being told it's missing rather than having it filled in
A [FIDELITY BLOCKED] packet doesn't get to enter Phase 1 and chance its arm. The grading happens before the laundering opportunity, not after, because once material has been through Exploration and Engineering it's indistinguishable from verified procedure.
The extractor was written, then run. Those turned out to be different activities, in the way that writing a feature and shipping it are different activities.
Running it against a real 17,000-word auto-captioned video found that half the transcript was duplicate text. YouTube's auto-captions use a rolling window, so each cue repeats the tail of the previous one, truncated mid-word at the boundary. Exact-containment de-duplication catches none of it, because no rolling cue is ever an exact substring of its predecessor.
Measured: 16,895 words on a transcript that actually held 8,513. Step count 292 against a true 173 or so. Fidelity read 0.68 when the honest number was 0.49.
Note the direction. The duplicates re-counted as verified steps and padded the numerator, so the bug made the output look better than it was. A grader that flatters its own results is worse than no grader, because at least no grader doesn't get trusted.
Two more fell out of the same session. fetch_metadata had no player-client fallback while fetch_cues did, so a run could pull a perfect transcript and then die fetching the title. And eval A1's fixture was a real video that stopped being unretrievable once the fallback chain landed, silently changing what the test measured from "refuses when there's nothing there" into "fails to fetch something that's there". Negative fixtures have to be structurally negative, not incidentally so.
All three are in the Kaizen log with measurements. That's the whole point of keeping one.
For two versions skill-builder shipped a Relationship Contract Engine doing substantially the same job as the standalone bidirectional-link-engine. Reciprocal contracts, weighted relationship types, auditing for half-wired networks. Neither file mentioned the other.
Which would be unremarkable, except that skill-builder's own operating rules say, in writing, at every phase boundary: does another installed skill already solve part of this? If yes, link rather than duplicate.
It had never once asked itself. The contract engine now delegates, and the note stayed in the root rather than being quietly deleted, because the interesting part isn't the duplication. It's that a rule can sit in a file for two versions without ever being applied to the file it's sitting in.
v3.0.0 reconciles two lineages that had been developing separately and cheerfully re-solving each other's problems.
One had the Kaizen loop, bidirectional flow declarations, and a token protocol. The other had cascade-prevention change control, a full engineering specification template, and roughly ten times the content. Neither was a superset of the other, so neither could just win.
The numbers made the direction obvious once anyone counted:
| 2.0.0 | 2.3.1 | |
|---|---|---|
| Subskills | 7 | 6 |
| Total lines | 164 | 1,764 |
| Average per file | 23 | 294 |
| Kaizen phase | yes | absent |
| Cascade control | absent | yes |
Good skeleton, deep muscle, one of each. So v3.0.0 is 2.3.1's content restructured into 2.0.0's architecture. references/merge-notes.md records what came from where, and what got dropped, so the next person doesn't have to reconstruct it from changelogs the way I just did.
A skill that mentions another skill in passing hasn't been linked to it. It's name-dropped it.
Every declared link carries a direction, a strength, a stated reason, and a matching reverse contract written out in full at the other end. The audit reports a status per link, and PENDING is an honest state that should appear often, because applying a reverse contract usually means editing a package that isn't the one you're working in.
This has history. Twenty-six broken reciprocal links once survived three consecutive audits, because every audit checked that link blocks existed rather than that links matched. Presence checking is theatre. It's also the default behaviour, which is why it keeps happening to people who know better. The interesting part is that someone noticed and fixed it, rather than quietly documenting the ones that were "mostly working", which is what would have happened five years ago.
Current state across both packages: some VALID, some PENDING, none BROKEN, and the table says so rather than rounding up to a nice number. The three PENDING ones have full reverse text ready in LINKING.md — they're not lost or awaiting design work, they're waiting for edits in three separate packages, which is the correct precondition for a paste.
git clone https://github.com/TABARC-Code/skill-builder-system.git
cp -r skill-builder video-workflow-extractor ~/.claude/skills/For the extractor's scripts:
pip install yt-dlp srt
python scripts/intake.py "https://www.youtube.com/watch?v=..." > packet.json
python scripts/grade.py packet.json
python scripts/run_evals.py --with-livegrade.py exits 0 on a fidelity pass and 2 on any block, so it drops into CI without wrapping.
In both packages, SKILL.md is the only installable entry point. Everything under subskills/ and references/ is load-on-demand and deliberately carries no frontmatter, so it can't fire behind the router's back.
That last detail isn't paranoia. An earlier version shipped six sub-skills each with their own name and description, meaning every one of them could trigger independently, and one collided with an unrelated installed skill called skill-creator. Cheap to check at build time. Expensive to find in the wild, and faintly humiliating.
YouTube access is intermittent. Bot-gating from datacentre IPs, plus TLS trouble behind a MITM proxy. Both are documented with working fixes in subskills/environment-setup.md (the new Phase 1a environment guide). The player-client fallback chain is ordered by what worked when it was tested, and that ordering will rot, because YouTube changes its gating whenever it feels like it. When every client fails, the pipeline refuses rather than inventing a transcript. That refusal path is tested, because that's precisely the moment fabrication is tempting.
The grader is a floor, not a verdict. It applies the referent, parameter, and continuity tests mechanically. The quote test, whether a given quote genuinely states a step, is semantic and returns review. So the script can downgrade a grade on its own but can never promote one. Nothing is ever auto-Verified.
Link contracts: three PENDING, one VALID. Contract 1 (skill-builder) is now wired both ways and moves to VALID. Contracts 2, 3, and 5 (bidirectional-link-engine, book-knowledge-extraction, forensic-style-auditor) have full reverse text ready in LINKING.md, with copy-paste sections for each. Applying them is outside this scope but it's a paste, not a rediscovery.
skill-builder has no automated eval harness. The extractor has one. This doesn't. Suites B and C are structurally checkable and are the obvious next Kaizen pass.
Both skills declare links as contracts, with matching reverse text written out at both ends. The audit currently shows:
- Contract 1 (
skill-builder↔video-workflow-extractor): VALID — both ends applied, both directions wired - Contract 2 (
video-workflow-extractor→bidirectional-link-engine): ASYMMETRIC EXTERNAL — reverse text inLINKING.md, section "For bidirectional-link-engine" - Contract 3 (
video-workflow-extractor→book-knowledge-extraction): PENDING — reverse text inLINKING.md, section "For book-knowledge-extraction" - Contract 5 (
video-workflow-extractor↔forensic-style-auditor): PENDING CONDITIONAL — reverse text inLINKING.md, section "For forensic-style-auditor"
The full contract audit is in skill-builder/references/link-contracts.md. To complete the network, apply the reverse text from LINKING.md to the three packages. Each is a straightforward paste.
MIT.