Open source libraries are bundles. They package five forms of knowledge together — specification, evaluation, translation, curation, and trust — because the cost of translation (turning a specification into working code) has historically been high enough to justify bundling. You do the translation once, ship the result, and everyone uses that artifact.
AI coding agents are collapsing translation cost. When an agent can turn a behavioral specification into correct, tested code in any language, the economics of the bundle change. The translation — the .js, .rs, .py file — becomes a cached projection from a richer upstream representation, regenerable on demand.
When translation is cheap, the bundle breaks. What remains valuable is the specification (what correct behavior means), the evaluation (how to verify it), the curation (which algorithms and defaults to choose), and the trust (where it was validated and against what). The translation itself becomes commodity output.
A skill packages exactly the valuable residual: behavioral specs with test vectors, a dependency graph for subset extraction, per-language translation hints, a verified reference, and provenance annotations. An AI agent reads the skill and produces native code — zero dependencies, only the subset needed, verified against the same tests that define the spec.
Read the full argument: docs/thesis.md
A Claude Code plugin that demonstrates the thesis. Each skill is a self-contained code generation recipe backed by a verified TypeScript reference implementation. An agent translates the tested reference into native code in any target language, generating only the subset of nodes you need with zero external dependencies.
| Skill | Domain | Nodes | Tests | Coverage |
|---|---|---|---|---|
| robotics | Kinematics, IK, state estimation, PID tuning, path planning, drivetrains, LQR, MPC, SLAM | 39 | 936 | 100% |
| optimization | Numerical optimization (Nelder-Mead, BFGS, L-BFGS, CG, Newton, SA, and more) | 21 | 539 | 100% |
| cron-expressions | Cron expression parsing, matching, scheduling | 8 | 189 | 100% |
| math-expression-parser | Math expression tokenizer, parser, evaluator | 6 | 96 | 100% |
| when-words | Human-friendly date/time formatting | 5 | 124 | 100% |
| Skill | Purpose |
|---|---|
| create-special-skill | Create a new special skill from a spec, RFC, or existing library |
| propose-special-skill | Package and propose a skill for inclusion via GitHub issue |
Each skill uses progressive disclosure — four layers the translation agent reads in order:
- SKILL.md — Overview: node graph, subset extraction, design decisions
- nodes/<name>/spec.md — Per-node behavioral spec with test vectors and
@provenance - nodes/<name>/to-<lang>.md — Language-specific translation hints
- reference/src/<name>.ts — TypeScript source (consulted only if spec is ambiguous)
The agent generates only the nodes you request, in dependency order, running tests after each node. For the full technical explanation, see docs/how-it-works.md.
The thesis was tested through staged experiments across formats, languages, and models:
| Experiment | Design | Result |
|---|---|---|
| whenwords 3×3 | REF, SPEC, PROMPT × Python, Rust, Go | REF/SPEC 100%; PROMPT diverged on off-policy decisions |
| mathexpr 3×3×3 | 3 formats × 3 languages × 3 models (27 runs) | On-policy/off-policy distinction identified |
| mathexpr skill | SKILL × Python, Rust, Go | Skill format validated — REF correctness at PROMPT cost |
| optimize NM subset | SKILL × Python, Rust, Go | 108/108 tests pass, de-bundling confirmed |
Key findings reframed as evidence for the thesis:
- De-bundling works. Subset extraction (3 of 21 nodes) produces correct, self-contained translations with zero dependencies.
- Translation generates improvement signals. Spec ambiguities discovered during translation become structured feedback — each consumption improves the skill.
- Cross-validation builds trust. Test vectors verified against scipy v1.17.0 and Optim.jl v2.0.0, with
@provenanceannotations documenting source and validation date.
See research/ for the full hypothesis, evaluation methodology, and experiment results.
Add the Special plugin to Claude Code:
claude mcp add-plugin special --url https://github.com/caryden/specialThis makes all skills available as slash commands in your Claude Code sessions.
Each skill is a slash command. Pass the node names you want and an optional --lang flag:
/optimization nelder-mead --lang python
/robotics kalman-filter --lang rust
/cron-expressions all --lang go
/math-expression-parser evaluate --lang cpp
/when-words time-ago duration --lang swift
Default target language is TypeScript if --lang is omitted.
Dependencies are resolved automatically — request only the nodes you need and
the skill includes everything they depend on. For example, /robotics jacobian-ik --lang python
generates 8 nodes (the full DH kinematics chain) without you listing each one.
Not sure which nodes you need? Every skill has a built-in help guide:
/optimization help
/robotics help
/cron-expressions help
/math-expression-parser help
/when-words help
The help command walks you through an interactive decision tree — it asks
about your use case, recommends specific nodes, and suggests a target language.
For example, /robotics help covers common profiles (FRC, FTC, MATE ROV,
undergrad controls, hobbyist arm) and produces a ready-to-use recipe.
The skill generates native source code and tests in your target language:
- Zero external dependencies — all code is self-contained
- Only the subset you asked for — no bloat from unused algorithms
- Tests included — translated from the reference test suite with provenance annotations
- Verified — each node's tests run after generation to confirm correctness
All skill implementations are independently written. No code is derived from external libraries. The following are acknowledged for their contributions to the algorithms and validation methodology used in this project:
Algorithm sources:
- J.A. Nelder and R. Mead, "A Simplex Method for Function Minimization" (1965)
- J. Nocedal and S.J. Wright, Numerical Optimization, Springer (2006)
- S. Kirkpatrick, C.D. Gelatt, and M.P. Vecchi, "Optimization by Simulated Annealing" (1983)
- R.E. Kalman, "A New Approach to Linear Filtering and Prediction Problems" (1960)
- P. Corke, Robotics, Vision and Control, Springer (2023)
- K.J. Astrom and T. Hagglund, Advanced PID Control, ISA (2006)
- S.M. LaValle, Planning Algorithms, Cambridge University Press (2006)
- S. Koenig and M. Likhachev, "D* Lite" (2002)
Cross-validation references:
- SciPy v1.17.0 (BSD-3-Clause) — test vectors verified against
scipy.optimize.minimize - Optim.jl v2.0.0 (MIT) — test vectors verified against Optim.jl solvers
- FilterPy v1.4.4 — Kalman, EKF, UKF test vectors
- Robotics Toolbox v1.1.0 (Corke) — kinematics, DH, Jacobian
- python-control v0.10.2 — PID, LQR
- PythonRobotics — path planning, drivetrains
- OMPL v1.7.0 — RRT, RRT*, PRM
- GTSAM 4.2 — pose graph optimization
Cross-validation confirms behavioral equivalence: implementations produce the same
results as established libraries on standard test functions, documented via @provenance
annotations throughout the codebase.
Predicted and then validated by Drew Breunig's "A Software Library With No Code" (Jan 2026). Further informed by practical experience porting a subset of Optim.jl to TypeScript using AI agent translation with test-driven verification.
This project is licensed under the MIT License.