"Three structural wounds that prose skills cannot fix. 12 lifecycle skills that do. Install in 30 seconds."

👁

Try it

The TPMN Skill Standard v4 is MIT-licensed. Install the core skills into any project.
Full spec: TPMN Skill Standard v4 on GitHub

$ npx @gem_squared/tpmn-skill-install

$ claude --permission-mode auto

/init-session # bootstrap — must be first
/plan-work # decompose into contracted units
/proceed-work # execute one unit
/verify-work # Autonomously invoked to verify against contract — SUCCESS or FAILURE
/archive-work # proven. searchable. compounds.

I've been using SKILLs every day, with almost zero failure. That's not because I got lucky. It's because I stopped writing them as prose — and I built 12 lifecycle skills that orchestrate all the others, the way Unix commands orchestrate any pipeline.

The problem is not SKILL itself — it is the failure of linguistic precision, and the failure to select the correct skill for a specific situation.

Your skills break and you never know.

Three independent studies found the same thing: 56% non-invocation (Vercel), 50% success rate (Villega), 77% activation (Seleznov, n=650). No error. No warning. No log. Claude proceeds without the skill and the output looks plausible.

That is only one of three wounds.

The three wounds

1. Silent Scope Decay — your prose constraints dilute under context compaction. Your architecture boundaries drift between sessions. Neither failure is detectable.

2. Judgment Theater — you review AI output but have no contract to check against. The review feels real. It is structurally empty.

3. Trigger Collision — the wrong skill fires, or no skill fires at all, and the failure is unobservable. More skills, more ambiguity, more compounding.

What I did

I stopped writing skills as prose. I built 12 lifecycle skills that orchestrate all the others — the way Unix commands orchestrate any pipeline.

The skills don't encode domain knowledge. They govern the lifecycle of work itself: plan it, execute it, verify it against a typed contract, archive the proven result. The domain knowledge lives in contracts, not skills. The contracts compound. The skills stay fixed.

/plan-work → /proceed-work → /verify-work → /archive-work
 ^ |
 +──── /search-kg (proven patterns feed back) ──+

Every verified contract becomes searchable prior art for the next session. You never start from zero.

Taste it

npm i @gem_squared/tpmn-skill-install

The 12 skills. MIT-licensed. Works with Claude Code out of the box. No infrastructure. No server. Git + filesystem.

From GitHub: github.com/gem-squared/tpmn-skill

What the 12 skills do

They don't encode domain knowledge. They govern the lifecycle of work itself.

$ claude --permission-mode auto

/search-kg Search proven patterns from prior work
 |
/plan-work Write CONTRACTs (A → B | P) for each unit
 |
/proceed-work Execute one unit, verify inline, retry on failure
 | (repeat for each unit)
 |
/verify-work Verify Result vs CONTRACT.B (per-unit or batch)
 |
/archive-work Move to archive/, git commit, compounds.
 |
/extract-skill Convert proven contracts into reusable skills (optional)

Every unit of work has a CONTRACT:

• A — input state: what exists before the work
• B — output state: what must exist after (always a state, never an action)
• P — precondition: what must be true to start
• Clarity % — how well-defined the scope is (0–100)

The lifecycle stays fixed. The knowledge compounds. That is the inversion: stop growing your skill library, grow your contract archive.

How prose fails — and why contracts don't

Silent Scope Decay. Claude compacts long context by summarizing. "When preconditions hold, plan the work..." compacts to "Plans work" — constraints gone, silently. TPMN uses algebraic notation: P ≜ work ≠ ⊥ ∧ project_slug ≠ ⊥. Remove a conjunct and the formula visibly breaks. Breakage is detectable, not silent.

Judgment Theater. "Does it look right?" is not verification. /verify-work runs three deterministic checks every time: field coverage (did B produce every required field?), type conformance, constraint satisfaction. STATE = SUCCESS is structural. Not an opinion.

Trigger Collision. 900,000+ skills in the ecosystem. Even in your private project, the same dynamic applies: more skills, more ambiguity, more compounding failure. TPMN solves this with two inversions — lifecycle orchestration (12 fixed skills, deterministic selection) and knowledge compounds (every verified contract becomes searchable prior art via /search-kg).

The full analysis

Each wound has a structural proof — why prose fails, why contracts don't, and how 130+ real work plans validated the model. Read the deep dive:

Three Wounds That Prose Skills Cannot Fix — The Full Analysis

The spec is public. CC-BY-4.0. The proof is verifiable. The rest is yours.

David Seo — GEM2.AI