🌐 English | 한국어 | 日本語 | 中文 | Español

20 skills for the full Claude Code project lifecycle — from setup to daily workflow to code review to session management to governance. Each skill is useful standalone; the full sequence covers everything.

What changed in v6.5.8: Refinement release — no skills added or removed; a targeted delta port from the internal fork since v6.5.7 (6 of the 20 skills changed upstream in that window, plus a hand-diffed code-autopsy port). doc-drift (new Derivability signal — a hardcoded-but-code-reconstructable fact is flagged as structurally drift-prone even when currently correct), integration-intake (new Analogy-trap check — an "X does it this way, so should we" value claim needs three answered questions before it counts as evidence), session-start (new Query-conditional load rule for on-demand memory files — load only after confirming the conversation is actually about that topic, not on keyword overlap alone), goal-lock (new optional EVAL TYPE field for tasks that measure a skill/hook/gate's own reliability, a Silent Self-Correction anti-pattern, a First-Attempt Ledger recording the raw pre-fix DONE EVIDENCE run before any changes, an Early Self-Doubt Boundary note against premature task abandonment from misjudged remaining budget), pre-push (code-reviewer unavailability now falls back to an inline abbreviated review instead of an outright skip; new Step 3.5 Public-Mirror Scrub — a WARN-only push-time backstop for repos that are curated public mirrors of a private source; new opt-in high-risk gap-sweep second pass and opt-in multi-angle parallel re-attack; skip-reason logging added to the Fix loop), session-checkpoint (new Stage 1, CT promotion queueing — scripts/ct_promotion_queue.py, opt-in via a marker file, pure deterministic token-overlap clustering with no LLM judgment and no writes to MEMORY.md/context-log.md itself, ships with a 35-case regression suite; invocation-log skip condition clarified to reuse only the activity-volume legs of the Triple Gate, deliberately not the 24h leg meant for a different auto-trigger), code-autopsy (7 more code-smell terms + explicit SOLID-principle naming for dependency-direction violations, a wrapper/proxy forwarding-correctness check, a governing-rules violation check quote-only with no inferred "intent", Q3 gained off-by-one/falsy-zero/copy-paste/unescaped-regex plus Python's mutable-default-argument and late-binding-closure traps, Q7's memory-leak check now names closure-captured-large-object as a pattern, STEP 0 gained a function-level contract check + explicit diff-scope pinning + governing-CLAUDE.md/rules discovery, a new re-established-invariant check for every deleted/replaced line, and a new [FAST MODE] --fast tier between the full pipeline and Quick Mode).

What changed in v6.5.7: Refinement release — no skills added or removed; several gained working deterministic scripts in place of LLM self-scoring. project-overview (generate_overview.py is no longer a stub — fully implemented registry parsing, state-snapshot extraction, and AUTO-block render/replace, with untrusted-input table-cell escaping and malformed-marker recovery, backed by unit + integration tests), scope (Quick/Full ambiguity gating and BRIEF.md min-item validation now run through a ported ambiguity_gate.py, with a regression test locking a bold-text-as-header counting bug), skill-ops → v1.2 (Health Mode bucket classification and Quality Mode S/U/S_Q scoring now run through skill_health_bucket.py instead of manual arithmetic), collab-audit (Step 0.6 source-hygiene filtering now runs through session_hygiene_scan.py), session-checkpoint (new Discoverability Check step flagging memory writes with no index backlink, a timeout/kill partial-output guard, two Reflexion lesson-quality gates, a PII-redaction rule for raw observations, and Key Files verification moved to a validate_memory_claims.py script), goal-lock (scope-check surface widened to interface/API changes not just touched files, a benchmark-backed chain-length dominant-variable note, the Stop-hook order gate upgraded to a verified 4-condition implementation, a new Safety Layers section, enum-style VERIFY failure labels, a self-judgment caveat on REFINE's DELTA CHECK, and a background-task termination handshake), code-autopsy (a Rationalization Table of 8 common reviewer rationalizations + rebuttals, and a note recommending script-based severity arithmetic over mental math), eval-leakage-audit (17→18-pattern taxonomy — adds Goodhart co-evolution in self-improving loops — plus a Reviewer Independence Honest 4-Label check), integration-intake (read-only tools: frontmatter, redirect-style not_for entries, 7 fixed misjudgment-enum labels per phase), pre-push (explicit depends_on/concurrency_profile frontmatter, an Autonomy Boundary note distinguishing read-only git commands from the gated git push, an external security-catalog reference link), session-start (depends_on/concurrency_profile frontmatter, Phase 2.2-2.4 rewritten to deterministic commands with fixed stdout contracts, a new unnumbered L0 Inheritance section), doc-drift (new Step 0 deterministic pre-filter feeding the Risky/Ambiguous category as supporting evidence only), and depends_on/concurrency_profile frontmatter adopted across full-audit, project-check, project-init, freeze, stepback, next-action, and clean-room, several of which also gained tool-category-tagged Scope Boundary tables. Known gap surfaced by this release: project-check (and a few siblings) gained unnumbered "inherited principle" notes on Safety Layers/Error Recovery headers — a past release deliberately stripped numbered (L0 §N) citations from these same headers across all 10 skills; this version's notes are unnumbered/generic rather than the removed citations, but the header-annotation pattern itself is back. Worth a conscious call before the next release builds further on it.

What changed in v6.5.6: Refinement release — no skills added or removed. eval-leakage-audit (13→17-pattern taxonomy — respawn masking, pseudo-replication, stimulus-calibration gap, unaudited cost-saving skips), goal-lock (an S7 stop rule that blocks forcing an implementation through when execution evidence contradicts an explicit instruction, a 5-tier evidence-rigor ladder + failure-first reporting order + banned hedge phrases, a "layer laundering" success-masquerade pattern, and an evidence-rigor pre-spec note), full-audit (a composite-accumulation-gate that flags death-by-thousand-cuts risk when UNCERTAIN/NIT findings pile up in one area even though each was individually dismissed, and an Assumption Ledger for CONFIRMED verdicts that rest on unverified assumptions), session-checkpoint (optional regime/escalate_if lesson fields, an optional outcomes field tracking first-attempt-pass/rework/resolvedBy, and a second lessons-archival OR-condition plus a mandatory cross-reference check before archiving), code-autopsy → v7.2 (a code-smell vocabulary for Q1, a concrete-failure-scenario requirement, object-level authorization under Q5, expanded network/DB/streaming/cache checks under Q7, a shallow-module + ADR-conflict check under Q8, a numeric confidence-threshold system, and an outcome-ceiling-to-process-metric switch for tied comparisons), pre-push → v3.8.0 (ships scan_secrets.py alongside the existing scan_secrets.pl — Python preferred when present, Perl as fallback — plus LICENSE.txt for upstream attribution; note: the two scanners' pattern coverage was found to differ in this release, e.g. the Python port adds an f13 Slack-webhook check absent from Perl, and several existing patterns cover a narrower or wider set of variants on each side — documented as a known gap, not yet reconciled).

What changed in v6.5.5: Refinement release — no skills added or removed. eval-leakage-audit (8→13-pattern taxonomy — dual-fail-flag, asymmetric-baseline self-falsification, evidence-burn, an ungraded-grader 4-gate check, ceiling-task detection — plus a stratification-substantiation checklist and an honest reviewer-independence 4-label verdict), goal-lock (an order gate that blocks completion when no verification ran after the last edit, evidence-channel branching for non-exit-code deliverables, a comprehension check, and three new success-masquerade guards), pre-push → v3.7 (cross-bundle joint pass + a three-state false-positive gate), integration-intake (headroom pre-classification, trait-vs-procedure termination, triple-check effectiveness claims), session-start (added claude-sonnet-5 to the model-ID allowlist — fixed a false "invalid model" warning), setup (removed a duplicate /setup trigger), full-audit (a rule-dry-run verification layer), clean-room (reconciled with upstream autobahn v0.14.0 — an N=1 cap on the independent re-sweep), code-autopsy (Q10 oracle-redefinition detection), plus smaller refinements to session-checkpoint, skill-ops, collab-audit, and scope.

What changed in v6.5: New: eval-leakage-audit (audits whether an eval/metric/holdout actually secures independent external ground truth vs circular self-confirmation, via an 8-pattern taxonomy; read-only), doc-drift (audits the memory/docs Claude Code loads into context — CLAUDE.md/MEMORY.md/skills/agents/commands — for outdated claims, mutual contradictions, and risky/ambiguous wording, producing a prioritized fix list). Updated: project-init (fixed a skill.md→SKILL.md filename-casing bug that could break skill loading on case-sensitive filesystems, and moved the Phase 3 templates into references/templates.md), pre-push → v3.6 (two new secret-scanner patterns — f11 prompt-injection strings in diffs, f12 non-PyPI supply-chain index URLs — plus a Step 0 Hook Pipeline Health check), scope (added the Mid-Task Scope Drift 10x-Discovery Rule), collab-audit (added Step 0.6 Source Hygiene Filter to exclude auto-derived subagent/thread sessions), full-audit and integration-intake (both gained a Safety Layers section; integration-intake also added a Phase 1.8 M-axis surface-selection step — judge which surface (prompt/rule/hook/skill) a pattern should live on before routing), goal-lock (added a migration task template), project-overview (added a Rationalization Table), stepback (added a Dominant Variable section + frontmatter fields).

What changed in v6.4: New: full-audit (exhaustive area audit — deterministic sweep + content review, persistent coverage map, anti-false-positive kill-test), integration-intake (5-item screening gate for adopting external skills/agents/rules/plugins, with a provenance/injection check), clean-room (carves safety-adjacent requests into a safe scope executed by a genuinely isolated fresh-context subagent, adapted from LilMGenius/paperthin's "autobahn" skill under MIT with a filesystem-isolation and ledger-timing upgrade). Updated: goal-lock (a constraint re-echo check at long-task checkpoints, so CONSTRAINTS/SCOPE-Exclude don't quietly fall out of view during extended work), session-checkpoint (a new Attestation phase — an evidence-chain receipt log with a bundled handoff_attestation.py, so the next session's SessionStart hook can detect handoff tampering).

What changed in v6.3: New: skill-ops (snapshot/rollback + usage health + invocation tracking hub), next-action (reads handoff/git/lessons/STATE and proposes the top-3 next actions), project-overview (deterministic cross-project status map). code-autopsy → v7.1 (deeper sub-checks per question), pre-push → v3.5 (9 supply-chain IOC patterns), goal-lock/session-checkpoint/session-start/scope/stepback/freeze all strengthened. All 12 prior skills gained not_for and see_also frontmatter for better discoverability.

New project (15 min):

/project-init       →  CLAUDE.md + ROADMAP + .gitignore + .env.example
/setup              →  rules/ + hooks + memory/ + agent routing + team
then daily:
  /session-start      at the start of every session
  /scope              before each feature (define IN/OUT/exit criteria)
  /freeze             before implementation (declare editable zone)
  /goal-lock          lock the goal, enforce PLAN→DO→VERIFY loop
  /stepback           anytime — zoom out, check direction, 10 lines
  /next-action        anytime — reads current state, proposes top-3 next actions
  /code-autopsy       12Q code review with severity scoring + verdict
  /pre-push           before each push (secrets scan + agent review)
  /session-checkpoint at the end of every session

Existing project (5 min):

/project-check      →  Score across 4 dimensions + gap list by severity
/collab-audit       →  14-section AI collaboration diagnostic from your work patterns

Governance & audits (as needed):

/integration-intake →  before adopting an external skill/agent/rule/plugin — 5-item screening gate
/full-audit         →  exhaustive area audit (codebase/docs/skills/memory/config) with a coverage map
/clean-room         →  when a task mixes safety-adjacent material with genuinely safe work
/eval-leakage-audit →  before trusting an eval/metric/holdout — check for circular self-confirmation
/doc-drift          →  audit loaded context (CLAUDE.md/MEMORY.md/skills) for outdated/contradictory wording

┌─────────────────── Setup (once) ───────────────────┐
│  /project-init  →  /setup                           │
└────────────────────────────────────────────────────┘
         ↓
┌─────────────────── Daily Loop ─────────────────────┐
│  /session-start                                     │
│       ↓                                             │
│  /scope → /freeze → /goal-lock → work                │
│       → /stepback (anytime) → /code-autopsy           │
│       → /pre-push                                     │
│       ↓                                             │
│  /session-checkpoint                                │
└─────────────────────────────────────────────────────┘
         ↓
┌─────────────────── On Demand ──────────────────────┐
│  /stepback         (perspective reset — anytime)      │
│  /project-check    (health audit)                    │
│  /code-autopsy     (12Q code review — any LLM)       │
│  /collab-audit     (behavioral diagnostic)           │
│  /integration-intake (before adopting external work) │
│  /full-audit       (exhaustive area audit)           │
│  /clean-room       (safety-adjacent scope carve-out) │
│  /eval-leakage-audit (eval circular-logic check)     │
│  /doc-drift        (loaded-context drift audit)      │
└─────────────────────────────────────────────────────┘

Each skill is a standalone directory with a SKILL.md file. Copy the ones you want:

# Install all skills
git clone https://github.com/AlexZio00/sovereign-skills.git
cd sovereign-skills
for d in */; do [ -f "$d/SKILL.md" ] && cp -r "$d" ~/.claude/skills/; done

# Or install one skill
cp -r goal-lock ~/.claude/skills/

This repo is a Claude Code marketplace. Register it once and browse/install skills:

# Add sovereign-plugins marketplace in Claude Code
# Settings → Plugins → Add Marketplace → https://github.com/AlexZio00/sovereign-skills.git

Each skill also includes standalone .claude-plugin/plugin.json metadata.

Skills are invoked by typing the trigger command (e.g., /goal-lock) in Claude Code. Claude reads the SKILL.md and follows the instructions.

Each skill includes agents/openai.yaml for Codex compatibility:

# Install a skill for Codex
npx skills add AlexZio00/sovereign-skills --skill goal-lock --agent codex -g -y

# Install a skill for Cursor
npx skills add AlexZio00/sovereign-skills --skill goal-lock --agent cursor -g -y

# Install a skill for Claude Code (alternative to Option A)
npx skills add AlexZio00/sovereign-skills --skill goal-lock --agent claude-code -g -y

The SKILL.md content is universal — it works with any LLM that reads markdown instructions.

• Claude Code: CLI, desktop app, or web app (claude.ai/code)
• Codex: OpenAI Codex with npx skills support
• Cursor: Cursor IDE with skill plugin support
• Skills directory: ~/.claude/skills/ (Claude Code) or agent-specific path
• pre-push requires Perl (for scan_secrets.pl — included)

These 17 of the 20 skills (the original lifecycle set, the v6.4 governance additions, and the v6.5 audit additions — the v6.3 operations additions aren't mapped here yet) implement 17 of the 25 known agentic design patterns (Gulli 2026, Sairahul 2026):

1. Interview over template — Skills ask questions and generate filled content, not empty skeletons
2. Verification over trust — DONE EVIDENCE must be executed, not assumed. "It should pass" is not verification
3. Scope before code — Define IN/OUT/exit criteria before touching files. Freeze what you're not changing
4. Honest reporting — WORKING / PARTIAL / BROKEN labels. No silent brokenness, no mock deception
5. Session continuity — Start with handoff, end with checkpoint. Context survives across sessions

Skills declare relationships via see_also (related) and not_for (misuse guardrails) in their frontmatter. Key relationships:

Diagram (arrows = "hands off to" / "informs"):

setup ──> scope ──> freeze ──> goal-lock ──> pre-push
                                   │
                                stepback (anytime, any stage)
                                   │
session-start <──> session-checkpoint
                                   │
                            next-action (reads state, recommends)
                                   │
    integration-intake / full-audit / clean-room / eval-leakage-audit / doc-drift
                 (on-demand governance & audits, any stage)

See CHANGELOG.md for the full version history (v3.0 → v6.5.8).

MIT — see LICENSE.

Issues and PRs welcome. If you build a skill that fits the lifecycle, open a PR.

DM @AlexZio00 for custom skill development.