Skill X is an open-source collection of agent skills for Claude Code, Codex, GitHub Copilot, and other coding agents. It helps agents work with GPT-5.6-style execution rigor, multi-agent delegation, coding-agent interpretability with linear probes, and self-evolving workflows. Use it when you want more reliable coding, research, and orchestration behavior from agentic tools.
Built by anshmajumdar. Skills refined from public research, the GPT-5.6 Sol execution blueprint, and the BuilderIO/skills collection.
# Clone the repo
git clone https://github.com/anshmajumdar121/skill-x.git
cd skill-x
# Pick a skill to install (manual copy)
cp -r skills/think-like-gpt-5-6 ~/.mavis/agents/<your-agent>/skills/
cp -r skills/efficient-fable ~/.mavis/agents/<your-agent>/skills/
cp -r skills/skill-zero ~/.mavis/agents/<your-agent>/skills/
cp -r skills/super-skill ~/.mavis/agents/<your-agent>/skills/
# Or install all of them
for d in skills/*/; do
cp -r "$d" ~/.mavis/agents/<your-agent>/skills/
done
# Verify they registered
mavis skill listReplace
<your-agent>with your agent name (e.g.,mavis,claude,codex— wherever your skills live).
| Skill | Lines | What it does |
|---|---|---|
think-like-gpt-5-6 |
1,547 | Full rigor framework: 7-step loop, 10 principles, 20-row risk register, 8 validation layers, 6 acceptance + 10 rejection criteria, 18 adversarial review questions, 7-section pre-delivery checklist. Best for any non-trivial task. |
efficient-fable |
302 | Delegation pattern: orchestrator + cheap subagents. 5-step pattern, handoff packet format, vetting protocol, 3-5× cheaper + 2-4× faster on parallelizable work. |
skill-zero |
1,598 | Specialist: linear probes on the residual stream of coding-agent LLMs. Decode current program properties (well-formedness, full/partial correctness, regression) and predict future edit outcomes up to ~25 steps ahead. Built on Silva, Tu & Monperrus 2026 (arXiv:2607.05188). |
super-skill |
2,096 | Rigor + delegation synthesis. Two modes (rigor / delegation), mode-selection flow, vetting protocol, 5 delegation-specific risks. Self-evolving under a 7-clause constitution. |
- I have a non-trivial task and want auditable artifacts.
→
think-like-gpt-5-6 - I have codebase-heavy work that can be parallelized and I want
to save tokens. →
efficient-fable - I want to monitor / steer a coding agent's internal state
(mechanistic interpretability). →
skill-zero - I want both rigor AND delegation efficiency, in one skill.
→
super-skill - I want a skill that improves itself over time, with hard
guardrails against garbage. →
super-skill(the only one with the self-evolution protocol)
Apply the GPT-5.6 Sol execution-intelligence framework. Convert an imperfect request into a validated, auditable deliverable through the 7-step loop: Observe → Interpret → Decide → Act → Verify → Repair → Record. Backed by the 10 governing principles, the 9-stage architecture, a 20-row risk register, **6 acceptance
- 10 rejection criteria**, an 18-question adversarial review, and a 7-section pre-delivery checklist.
Best for: multi-step coding, research with citations, artifact creation, operational actions, high-stakes guidance, and any task where you want inspectable reasoning rather than a fluent black-box answer.
Read more: skills/think-like-gpt-5-6/SKILL.md
Use a high-cost frontier model as the orchestrator, architect, synthesizer, and final judge. Use cheaper subagents for the bounded heavy lifting (large repo scans, long log reduction, narrow code patches, browser/test verification). The vetting protocol says: treat subagent reports as leads, not facts — always reopen the cited file, confirm the line ref, and review the diff before shipping.
The 5-step delegation pattern: name the expensive risk → split into parallel slices → use cheap agents for the heavy work → ask for concise evidence → spend orchestrator tokens on the decision layer.
Best for: codebase-heavy work that can be sliced into independent parallel pieces. Skip for trivial tasks, high-stakes single-source work, or when no cheap subagents are available.
Read more: skills/efficient-fable/SKILL.md
Specialist in mechanistic interpretability of coding-agent LLMs via linear probes on the residual stream. Based on Silva, Tu & Monperrus 2026 (arXiv:2607.05188).
The skill teaches you how to:
- Predict edit outcomes before they hit disk. Train a logistic regression probe on hidden states to read off whether the about-to- be-written edit will introduce a regression (◆ Regression property) or fail tests (● Full Correctness).
- Tell whether the agent is making progress mid-trajectory. ■ Partial Correctness probe reads the agent's confidence about test-passing direction from its hidden states (AUC ~0.84 in the paper).
- See ~25 steps into the agent's plan. The "latent programming horizon" finding: a probe can flag, several steps ahead, that the trajectory is heading toward a failing state.
The skill includes the paper's specific numbers (AUC 0.83, horizon k≈25, mid-layer inverted-U pattern), the 4 canonical properties, the shuffled-label control discipline, the cross-benchmark transfer detail, and 5 concrete failure modes.
Read more: skills/skill-zero/SKILL.md
The synthesis: rigor + delegation in one skill. Two operating modes:
- Rigor mode (default) — use the GPT-5.6 Sol 7-step loop, 10 principles, 9-stage architecture, task classification, risk register, validation layers, acceptance/rejection criteria, adversarial review, and pre-delivery checklist.
- Delegation mode — for codebase-heavy or token-heavy work that can be split into independent parallel slices, use the Efficient Fable delegation pattern with the vetting protocol.
The mode is selected during intake. The skill also includes 5 delegation-specific risks (R-D1 through R-D5), a 9th test (T-09: subagent report vetting), and the vetting protocol built into the test matrix.
Self-evolving. The skill can grow, improve, and prune itself
over time, under a strict internal 7-clause constitution that
prevents garbage. The constitution (in
skills/super-skill/references/self-evolution.md):
- C-1 Evidence-based — every change must cite a paper, official doc, code link, or verified observation
- C-2 Bounded scope — only rigor + delegation frameworks, not user projects
- C-3 Conservative — no speculative additions
- C-4 Quality floor — new content must be at least as good as what it replaces
- C-5 Reversible — every change has a changelog row
- C-6 No-garbage filter — reject vague filler
- C-7 Privacy — no personal data, no project-specific content
Any single clause failing = reject the change. No exceptions.
Read more: skills/super-skill/SKILL.md
┌────────────────────────────────┐
│ user task arrives │
└───────────────┬────────────────┘
│
▼
┌────────────────────────┐
│ what kind of task? │
└────────┬───────────────┘
┌───────────────────┼────────────────────────┐
│ │ │
general task code-anything I have multiple
│ with hidden agents + I want
│ state access a meta-framework
▼ │ │
┌─────────────────┐ ▼ ▼
│ think-like- │ ┌─────────────┐ ┌──────────────────┐
│ gpt-5-6 │ │ skill-zero │ │ super-skill │
│ │ │ │ │ (rigor+deleg., │
│ 7-step loop │ │ linear │ │ self-evolving) │
│ 10 principles │ │ probes on │ │ │
│ risk register │ │ hidden │ └──────────────────┘
│ validation │ │ states │ │
└────────┬────────┘ └─────────────┘ │
│ │
└──────────────────┬─────────────────────┘
│
▼
┌─────────────────────┐
│ efficient-fable │
│ (delegation pattern)│
│ │
│ 5-step pattern, │
│ handoff packets, │
│ vetting protocol │
└─────────────────────┘
▲
│
used inside super-skill in delegation mode
used standalone for token-heavy parallel work
super-skill is the recommended default for most complex tasks. It
contains:
- The full TLG rigor framework (as the outer loop)
- The Efficient Fable delegation pattern (as a fast lane)
- The self-evolution protocol (with the 7-clause constitution)
The other three skills remain available for their specific triggers.
The skills are designed to be dropped into any agent's skills directory. There are three install paths — pick whichever your agent supports.
This repo ships as a Claude Code plugin marketplace and a Codex plugin so you can install with one command:
# Claude Code
/plugin marketplace add anshmajumdar121/skill-x
/plugin install skill-x@skill-x
# Codex
codex plugin install anshmajumdar121/skill-x
# Or generic npx (Vercel's skills CLI)
npx skills@latest add anshmajumdar121/skill-x --skill super-skillSee PLUGIN_INSTALL.md for the full per-agent
install matrix (Claude Code, Codex, OpenCode, Copilot, plus the
generic cp -r fallback).
# Clone
git clone https://github.com/anshmajumdar121/skill-x.git
cd skill-x
# Install one
cp -r skills/super-skill ~/.mavis/agents/<your-agent>/skills/
# Install all
for d in skills/*/; do
cp -r "$d" ~/.mavis/agents/<your-agent>/skills/
done
# Verify
mavis skill list| Agent | Skills path | Plugin? |
|---|---|---|
| mavis | ~/.mavis/agents/<name>/skills/ |
n/a |
| Claude Code | ~/.claude/skills/ (user) or .claude/skills/ (project) |
yes — .claude-plugin/marketplace.json |
| Codex CLI | ~/.codex/skills/ (user) or .codex/skills/ (project) |
yes — .codex-plugin/plugin.json |
| OpenCode | ~/.config/opencode/skills/ (user) or .opencode/skills/ (project) |
manual only |
| GitHub Copilot | .github/skills/ (project) or VS Code user dir |
manual only |
# Lint a single skill
node $(mavis skill show skill-creator | python3 -c 'import json,sys;print(json.load(sys.stdin)["location"])' | xargs dirname)/scripts/lint-skill.js skills/super-skill/
# Lint all skills in this repo
./scripts/lint-all.shsuper-skill is the only skill that evolves itself. The protocol
lives in
skills/super-skill/references/self-evolution.md.
Triggers:
- Explicit: "evolve this skill", "superskill evolve"
- Stale-content detection: a specific number, link, or claim is demonstrably out of date
- Better-technique detection: a clearly better technique becomes available
- Garbage-content detection: a section no longer earns its place
The 5-step procedure: Detect → Evidence → Constitution check
(all 7 clauses) → Apply → Verify (re-lint). The changelog at the
top of super-skill/SKILL.md records every change.
What is the think-like-gpt-5-6 skill?
A GPT-5.6-style execution-rigor skill for coding agents. It applies a
7-step Observe → Interpret → Decide → Act → Verify → Repair → Record
loop, 10 governing principles, and a pre-delivery checklist to any
non-trivial task, so the agent produces auditable, verified output
instead of a fluent black-box answer.
Does Skill X work with Claude Code, Codex, and GitHub Copilot?
Yes. Skill X ships a Claude Code plugin marketplace
(.claude-plugin/marketplace.json) and a Codex plugin
(.codex-plugin/plugin.json), plus manual install paths that work with
any agent that reads a skills directory, including GitHub Copilot's
.github/skills/ convention. See Install below.
How is efficient-fable different from other delegation patterns?
It generalizes the delegation pattern beyond a single agent: a
high-cost frontier model acts as orchestrator/judge, cheap subagents
handle bounded heavy lifting, and a vetting protocol requires every
subagent report to be independently re-verified before it's trusted.
What does skill-zero actually do?
It's a specialist skill for coding-agent interpretability: linear
probes on the residual stream of a coding-agent LLM, used to predict
edit outcomes, detect regressions, and see up to ~25 steps into the
agent's plan before it fails. Based on Silva, Tu & Monperrus 2026
(arXiv:2607.05188).
What makes super-skill "self-evolving"?
It can revise its own content over time under a strict 7-clause
constitution (evidence-based, bounded scope, conservative, quality
floor, reversible, no-garbage-filter, privacy) — every change is
evidence-cited and logged in a changelog, and any clause failing
rejects the change outright.
We welcome contributions. See CONTRIBUTING.md for the workflow, and the in-skill self-evolution protocol for guidance on the quality bar. The short version:
- Each skill is self-contained. Keep it that way.
- Reference docs are progressive disclosure —
SKILL.mdis the front matter,references/*.mdis the detail. - Lint passes required:
./scripts/lint-all.sh. - No external network calls at runtime. Skills are static markdown.
- No personal data, no project-specific content.
| Skill | Source | Synthesized |
|---|---|---|
think-like-gpt-5-6 |
GPT-5.6 Sol Execution-Intelligence Blueprint (v1.0, 2026-07-16) | distilled into 7-step loop, 10 principles, 9-stage architecture, 20-row risk register |
efficient-fable |
BuilderIO/skills | retweaked: generalized beyond Fable, added when-NOT-to-use, cross-referenced to the rest of the collection |
skill-zero |
Silva, Tu, Monperrus 2026 (arXiv:2607.05188) | extracted the linear-probe methodology, 4 canonical properties, expected AUC numbers, 5 failure modes |
super-skill |
synthesis of think-like-gpt-5-6 + efficient-fable |
added 5 delegation risks, mode-selection flow, vetting protocol, 9th test T-09, self-evolution protocol with 7-clause constitution |
MIT. See LICENSE.
- PLUGIN_INSTALL.md — full per-agent install matrix (Claude Code, Codex, OpenCode, Copilot, manual)
- CONTRIBUTING.md — how to add or modify a skill
- LICENSE — MIT
- SECURITY.md — how to report a security issue
- CITATION.cff — how to cite this collection
- .github/workflows/lint-skills.yml — CI that lints every skill
- scripts/lint-all.sh — local equivalent
- .claude-plugin/marketplace.json — Claude Code plugin manifest
- .codex-plugin/plugin.json — Codex plugin manifest
Built with rigor + delegation + a 7-clause constitution. Star if useful.