skilldrop-cli 0.16.3__py3-none-any.whl

skilldrop_cli/data/model-routing.json

@@ -0,0 +1,474 @@
+{
+  "$comment": "Provider-neutral, cost-aware model routing for skilldrop skills. Skills declare an ABSTRACT tier (light/standard/heavy) describing how much reasoning the task needs. The `providers` map resolves that tier to a concrete model for whatever tool you use (Claude Code, Cursor, Codex, Kiro, ...). Set `active_provider` to your tool. Tier is decided ONCE per skill (the decision is stable), not re-derived per call \u2014 that keeps routing free. Runtime heuristics in `escalation_rules` handle the cases that actually vary.",
+  "version": "0.2.0",
+  "active_provider": "claude-code",
+  "tiers": {
+    "light": {
+      "use_for": "Mechanical mapping, extraction, and lookup against a fixed rubric. Deterministic enough that a small/cheap model matches a large one.",
+      "relative_cost": 1
+    },
+    "standard": {
+      "use_for": "Most generation. Synthesizing a structured artifact from a brief, where quality matters but the reasoning is not adversarial. The default tier.",
+      "relative_cost": 4
+    },
+    "heavy": {
+      "use_for": "Adversarial reasoning and weighted judgment, where a cheaper model demonstrably misses edge cases, under-calls severity, or mis-weights tradeoffs. Spend here only when the hard thinking IS the value.",
+      "relative_cost": 20
+    }
+  },
+  "providers": {
+    "claude-code": {
+      "label": "Claude Code (Anthropic)",
+      "models": {
+        "light": "claude-haiku-4-5-20251001",
+        "standard": "claude-sonnet-5",
+        "heavy": "claude-opus-5"
+      },
+      "select_via": "`/model <model-id>` in the session, or hand the skill to the model-router agent for automatic dispatch.",
+      "automation": ".claude/agents/model-router.md"
+    },
+    "cursor": {
+      "label": "Cursor",
+      "models": {
+        "light": "<your cheapest capable model, e.g. a small Claude/GPT/Gemini>",
+        "standard": "<your default model>",
+        "heavy": "<your most capable model>"
+      },
+      "select_via": "Pick the model in the chat/composer model dropdown before invoking the skill. Cursor rules cannot switch models programmatically \u2014 this is a manual lookup.",
+      "automation": null,
+      "note": "Cursor exposes whatever models your plan enables (Claude, GPT, Gemini). Fill in the three you actually use."
+    },
+    "openai-codex": {
+      "label": "OpenAI Codex CLI",
+      "models": {
+        "light": "<your cheapest OpenAI model>",
+        "standard": "<your default OpenAI model>",
+        "heavy": "<your most capable OpenAI model>"
+      },
+      "select_via": "Set the model via the Codex `--model` flag or its config before running the skill.",
+      "automation": null,
+      "note": "Fill in with the model identifiers your Codex install accepts. Model names change \u2014 verify against `codex --help` / your config."
+    },
+    "kiro": {
+      "label": "Kiro",
+      "models": {
+        "light": "<your cheapest capable model>",
+        "standard": "<your default model>",
+        "heavy": "<your most capable model>"
+      },
+      "select_via": "Select the model in Kiro's model picker, or pin it in the custom-agent / steering definition that loads the skill.",
+      "automation": null
+    },
+    "generic": {
+      "label": "Any other tool",
+      "models": {
+        "light": "<your cheapest capable model>",
+        "standard": "<your default model>",
+        "heavy": "<your most capable model>"
+      },
+      "select_via": "However your tool selects a model. The tier tells you which of your three to pick.",
+      "automation": null
+    }
+  },
+  "escalation_rules": [
+    {
+      "id": "large-input",
+      "rule": "Escalate one tier (light\u2192standard, standard\u2192heavy) when the input the skill must reason over exceeds ~30 pages / ~20k words / ~15 source files. Large context degrades small models faster than large ones.",
+      "type": "heuristic_no_llm"
+    },
+    {
+      "id": "reasoning-floor",
+      "rule": "Never downgrade a skill whose tier is 'heavy'. These are the reasoning skills; downgrading defeats their purpose. The router may upgrade but never demote below the skill's declared tier.",
+      "type": "hard_constraint"
+    },
+    {
+      "id": "ambiguous-input",
+      "rule": "Escalate one tier when the input is contradictory, underspecified, or the user explicitly asks for the most rigorous output ('be thorough', 'this is going to the board'). Do NOT escalate just because the topic sounds important.",
+      "type": "heuristic_no_llm"
+    },
+    {
+      "id": "downgrade-trivial",
+      "rule": "Downgrade one tier (never below 'light', never below the skill's declared floor) when the input is tiny and templated \u2014 e.g. a one-paragraph brief into adr-generator, a 3-line note into decision-log.",
+      "type": "heuristic_no_llm"
+    },
+    {
+      "id": "user-override",
+      "rule": "An explicit user model choice always wins. The router reports what it would have picked, then honors the override.",
+      "type": "hard_constraint"
+    }
+  ],
+  "skills": {
+    "audience-profile": {
+      "tier": "light",
+      "rationale": "Maps a fixed set of audience archetypes to structural rules. Lookup against a rubric, not synthesis."
+    },
+    "backlog-triage": {
+      "tier": "standard",
+      "rationale": "A script does the counting; the model confirms duplicates by reading, judges readiness and writes a reasoned ordering. Bounded judgment over structured data."
+    },
+    "cloud-cost-review": {
+      "tier": "standard",
+      "rationale": "A stdlib script does the aggregation; the model maps columns, checks evidence and computes savings with shown arithmetic against a fixed category checklist, which is bounded judgment."
+    },
+    "content-design": {
+      "tier": "standard",
+      "rationale": "Rewrites source text from user needs under fixed plain-language rules, with a script for the readability numbers. Prioritising questions needs judgment, but facts come from the source."
+    },
+    "dashboard-spec": {
+      "tier": "standard",
+      "rationale": "Structured spec from a decision and a metric list; the vanity-metric cut and chart choice need judgment but follow fixed rules."
+    },
+    "decision-log": {
+      "tier": "light",
+      "rationale": "Extracts decisions/owners/dates from notes. Pattern extraction; escalate on long transcripts via large-input rule."
+    },
+    "delivery-metrics-report": {
+      "tier": "standard",
+      "rationale": "A stdlib script computes every number; the model maps columns, checks data quality and interprets weekly trends against fixed DORA definitions, which is bounded judgment."
+    },
+    "design-system-spec": {
+      "tier": "standard",
+      "rationale": "Fills a fixed spec shape (anatomy, states, tokens, accessibility) against a checked WCAG list. Needs care on states and keyboard patterns, but the structure bounds it."
+    },
+    "dpia": {
+      "tier": "heavy",
+      "rationale": "Legal-structure judgment: screening, choosing a lawful basis per purpose, spotting inferred special category data and transfers, and scoring harm to individuals. Errors are costly and the input is usually incomplete."
+    },
+    "file-to-markdown": {
+      "tier": "light",
+      "rationale": "A deterministic stdlib script does the extraction; the model runs it, relays the dropped-content report and hands off. No generation beyond a short summary of losses."
+    },
+    "hypothesis-comparison": {
+      "tier": "heavy",
+      "rationale": "Judgment-heavy: generating real rivals, rating every evidence-hypothesis cell honestly and resisting the favourite theory is where a fast pass fails; the script only does the arithmetic."
+    },
+    "information-architecture": {
+      "tier": "standard",
+      "rationale": "Structured synthesis from a content list into groups, labels and a nav model against fixed IA practice. Grouping needs judgment, but the method and the validation plan bound it."
+    },
+    "md-to-docx": {
+      "tier": "standard",
+      "rationale": "A stdlib script does the conversion; the model restructures the Markdown so it converts cleanly (heading levels, footnotes, HTML), reads each warning and explains the losses. Bounded editing, no open-ended generation."
+    },
+    "md-to-html": {
+      "tier": "light",
+      "rationale": "A deterministic stdlib script does the conversion; the model picks options, fixes a few unsupported Markdown constructs and relays the script's warnings. Little judgment."
+    },
+    "md-to-xlsx": {
+      "tier": "standard",
+      "rationale": "A stdlib script types and writes the cells; the model shapes tables from the source (headings, units, one header row), decides whether formulas are safe to enable, and checks the per-sheet type counts against the data. Bounded, mostly mechanical judgment."
+    },
+    "mermaid-render": {
+      "tier": "standard",
+      "rationale": "The script lints and renders deterministically, but fixing a broken diagram means reading the author's intent and rewriting syntax without changing nodes, edges or labels, and knowing when to ask instead."
+    },
+    "metric-definition": {
+      "tier": "standard",
+      "rationale": "Structured specification against a fixed checklist (formula, grain, window, exclusions, edge cases, checks). Needs care with SQL and additivity but no adversarial judgment."
+    },
+    "research-plan": {
+      "tier": "standard",
+      "rationale": "Structured planning against a fixed shape (decision, sub-questions, methods, criteria, stopping rule); needs judgment to cut scope but no adversarial reasoning."
+    },
+    "risk-register": {
+      "tier": "standard",
+      "rationale": "Structured writing against a fixed format and scale, with a script doing the checks and counts. Scoring needs some judgment but is bounded by the written scale."
+    },
+    "service-blueprint": {
+      "tier": "standard",
+      "rationale": "Structured mapping of a described service into fixed lanes, with fail points, waits and a ranking. Tracing causes needs judgment, but the lane structure and the input bound it."
+    },
+    "skill-author": {
+      "tier": "standard",
+      "rationale": "Structured authoring against a fixed anatomy. The judgment is in the description and sibling boundaries, which the interview anchors; skill-review is the adversarial pass."
+    },
+    "skill-review": {
+      "tier": "heavy",
+      "rationale": "Adversarial audit with a verdict: routing collisions and paraphrased safety issues are what a fast pass misses, and the lint script covers only the mechanical half."
+    },
+    "soc2-evidence-map": {
+      "tier": "standard",
+      "rationale": "Maps controls against a fixed criteria set and a known Type I vs Type II evidence pattern. Judgment is needed on coverage and gap status, but the structure is bounded by the reference."
+    },
+    "sonar-onboard": {
+      "tier": "light",
+      "rationale": "Scaffolds config from detected language + a template. Deterministic fill-in; little judgment."
+    },
+    "adr-generator": {
+      "tier": "standard",
+      "rationale": "Structures a decision into MADR/Nygard. Some judgment on title/consequences; not adversarial."
+    },
+    "architecture-diagrams": {
+      "tier": "standard",
+      "rationale": "Translates prose to diagram syntax. Correctness matters; reasoning is bounded."
+    },
+    "brief-intake": {
+      "tier": "standard",
+      "rationale": "Extraction + tagging [explicit]/[implied]/[inferred]. The tagging needs care \u2014 above light, below heavy."
+    },
+    "deck-builder": {
+      "tier": "standard",
+      "rationale": "Shapes content, maps a brand template's layouts, and runs a script. Judgment, not hard reasoning."
+    },
+    "design-doc": {
+      "tier": "standard",
+      "rationale": "Synthesizes a design doc from a brief. Escalate to heavy via large-input or ambiguous-input when alternatives are genuinely contested."
+    },
+    "exec-summary": {
+      "tier": "standard",
+      "rationale": "Compression to one page. Needs to keep the right signal; escalate on very long source docs."
+    },
+    "figma-diagrams": {
+      "tier": "standard",
+      "rationale": "API calls + spec generation. Bounded transformation."
+    },
+    "guide-builder": {
+      "tier": "standard",
+      "rationale": "Shapes notes into a styled guide. Generation, not adversarial review."
+    },
+    "reverse-architecture": {
+      "tier": "standard",
+      "rationale": "Extracts architecture from code/IaC. Escalate to heavy on large codebases where cross-file inference is heavy."
+    },
+    "launch-readiness": {
+      "tier": "standard",
+      "rationale": "Checks evidence against a fixed checklist. Bounded synthesis, not adversarial review."
+    },
+    "brand-kit": {
+      "tier": "standard",
+      "rationale": "Extracts and normalises brand facts from files and pages, then runs a checker. Bounded synthesis."
+    },
+    "marketing-flyer": {
+      "tier": "standard",
+      "rationale": "Writes short copy to fit and fills a spec for a deterministic builder. Bounded generation."
+    },
+    "runbook-generator": {
+      "tier": "standard",
+      "rationale": "Operational doc from service facts. Bounded synthesis."
+    },
+    "slide-outliner": {
+      "tier": "standard",
+      "rationale": "Outlines a deck to a time budget. Structuring, not deep reasoning."
+    },
+    "sonar-review": {
+      "tier": "standard",
+      "rationale": "Formats Sonar API findings into a report. The hard analysis is Sonar's; this is synthesis. Escalate on very large diffs."
+    },
+    "ai-usage-report": {
+      "tier": "standard",
+      "rationale": "Tabulates telemetry into a report. Mostly mechanical, but the 'AI theater' effectiveness call needs judgment."
+    },
+    "ai-readiness-assessment": {
+      "tier": "standard",
+      "rationale": "Scores six fixed dimensions against a rubric and ranks gaps by blocking order. Bounded structured judgment, not adversarial reasoning; escalate via ambiguous-input when the evidence is thin or contested."
+    },
+    "agent-adoption-stage": {
+      "tier": "standard",
+      "rationale": "Places a team on a fixed 5-stage ladder from observables and routes one unlock. Bounded diagnosis against a rubric; escalate via ambiguous-input when the observables are contradictory or the distribution is heavily skewed."
+    },
+    "ai-use-case-triage": {
+      "tier": "standard",
+      "rationale": "Scores candidates on weighted axes and forces a rejection list. Structured comparison with stated weights; escalate via ambiguous-input when candidates are numerous or the value data is contested."
+    },
+    "ai-adoption-rollout": {
+      "tier": "standard",
+      "rationale": "Generates a phased people-rollout with gates and enablement from a stated tool and population. Structured planning against a fixed shape; escalate via ambiguous-input for large or politically contested rollouts."
+    },
+    "ai-usage-policy": {
+      "tier": "standard",
+      "rationale": "Drafts a policy document against a fixed structure (tiers, behaviours, review matrix, exception route). Bounded generation; escalate via ambiguous-input where a regulatory regime is named or contested."
+    },
+    "feature-implement-loop": {
+      "tier": "standard",
+      "rationale": "Code + test generation against acceptance criteria. The adversarial pass delegates to devils-advocate (heavy) where available; the loop itself is generation."
+    },
+    "pre-merge-review": {
+      "tier": "standard",
+      "rationale": "Orchestration: runs a deterministic gate script, dispatches the (heavy) reviewer subagents, and renders a rule-based go/no-go. The adversarial reasoning is delegated to the panel, so the skill itself is coordination."
+    },
+    "source-synthesis": {
+      "tier": "standard",
+      "rationale": "Bounded synthesis over supplied text with a fixed citation format and strength criteria; the citation checker catches the mechanical failures, so mid-tier judgment is enough."
+    },
+    "sql-review": {
+      "tier": "heavy",
+      "rationale": "Adversarial correctness review: finding join fan-out, NULL and timezone bugs means reasoning about data the query never shows, and a missed finding ships a wrong number. Never downgrade."
+    },
+    "team-status-report": {
+      "tier": "standard",
+      "rationale": "A script computes every count and the suggested RAG; the model writes plain-language summaries, attributes outside facts and frames risks and asks. Bounded writing over computed numbers."
+    },
+    "terraform-module": {
+      "tier": "standard",
+      "rationale": "Structured generation against fixed module conventions and a secure-defaults checklist; the judgment is bounded to choosing defaults and validation rules for a described need."
+    },
+    "terraform-plan-review": {
+      "tier": "heavy",
+      "rationale": "Adversarial review of a destructive change: judging which replacements lose data, which access changes widen exposure, and what is out of scope needs careful reasoning; a missed destroy costs far more than the model."
+    },
+    "tracker-brief-sync": {
+      "tier": "standard",
+      "rationale": "Maps doc sections to items and writes acceptance criteria that restate requirements; a script checks the spec, writes the import file and computes drift. Bounded transformation with a deterministic check."
+    },
+    "user-story-splitter": {
+      "tier": "standard",
+      "rationale": "Decomposes an epic into INVEST slices with testable ACs. Structured synthesis; escalation rules cover large or contradictory PRDs."
+    },
+    "test-plan-generator": {
+      "tier": "standard",
+      "rationale": "Synthesizes a structured plan from a change description. Risk ranking needs judgment but is bounded; escalate via ambiguous-input on contested or high-stakes releases."
+    },
+    "release-notes": {
+      "tier": "standard",
+      "rationale": "Classifies commits and rewrites them for a reader. The audience translation needs judgment; escalate via large-input on very long ranges."
+    },
+    "postmortem-generator": {
+      "tier": "standard",
+      "rationale": "Synthesizes a structured doc from incident notes. Contributing-factor chains need judgment but are bounded; escalate via large-input on huge scrollbacks."
+    },
+    "migration-plan": {
+      "tier": "standard",
+      "rationale": "Phased plan synthesis with a strong template. Ordering judgment is bounded by the expand/migrate/contract pattern; escalate via ambiguous-input on contested, high-stakes cutovers."
+    },
+    "api-contract-draft": {
+      "tier": "standard",
+      "rationale": "Schema synthesis against fixed conventions. The resource modeling needs judgment; the conventions bound it. Escalate via ambiguous-input on contested multi-team contracts."
+    },
+    "bug-triage": {
+      "tier": "standard",
+      "rationale": "Extraction plus judgment calls (severity vs priority, hypothesis ranking) \u2014 same shape as brief-intake: above light, below heavy."
+    },
+    "prd-draft": {
+      "tier": "standard",
+      "rationale": "Synthesizes a structured requirements doc from a brief. The solution-language discipline needs care; bounded by the template. Escalate via ambiguous-input on contested scope."
+    },
+    "nfr-spec": {
+      "tier": "standard",
+      "rationale": "Rubric-driven sweep with archetype defaults; the judgment is calibrating targets to business reality. Bounded by the catalog; escalate via ambiguous-input on contested SLOs."
+    },
+    "success-metrics": {
+      "tier": "standard",
+      "rationale": "Structured measurement design; the primary-metric and counter-metric choices need judgment but the template bounds it. Escalate via ambiguous-input when the goal itself is contested."
+    },
+    "requirements-interview": {
+      "tier": "standard",
+      "rationale": "Question banks are rubric-shaped, but ranking by design impact and deriving falsification conditions for the specific feature is synthesis \u2014 above light."
+    },
+    "business-case": {
+      "tier": "heavy",
+      "rationale": "Weighted multi-option judgment with a committal recommendation \u2014 same failure mode as tech-comparison-matrix: cheaper models mis-weight costs, inflate benefits, and miss the flip-assumption. Never downgrade."
+    },
+    "incident-comms": {
+      "tier": "standard",
+      "rationale": "Audience-segmented message generation under a strict don't-retract discipline. Same shape as exec-summary/audience-profile \u2014 translation and altitude, not adversarial reasoning."
+    },
+    "data-contract": {
+      "tier": "standard",
+      "rationale": "Schema + SLA synthesis against fixed quality dimensions and an evolution matrix. Semantics capture needs care; bounded by the catalog. Escalate via large-input on wide schemas."
+    },
+    "llm-eval-harness": {
+      "tier": "standard",
+      "rationale": "Methodology synthesis against a fixed decision tree and pitfall catalog. Grading-method and metric choices need judgment but are bounded; escalate via ambiguous-input on novel task types."
+    },
+    "capacity-cost-model": {
+      "tier": "standard",
+      "rationale": "Quantitative projection from a demand model against a fixed cost catalog. Headroom and scaling-cliff judgment is bounded by the reference; escalate via ambiguous-input on novel architectures."
+    },
+    "accessibility-audit": {
+      "tier": "heavy",
+      "rationale": "Adversarial review against WCAG success criteria \u2014 cheaper models fault alt-text presence over quality, under-call severity, miss focus-order/name-role-value issues, and claim AT passes from screenshots. Never downgrade."
+    },
+    "db-schema-design": {
+      "tier": "standard",
+      "rationale": "Design synthesis from access patterns against a fixed paradigm/indexing/anti-pattern reference. Paradigm and denormalization judgment is bounded; escalate via ambiguous-input on contested scale/consistency tradeoffs."
+    },
+    "observability-plan": {
+      "tier": "standard",
+      "rationale": "Methodology synthesis against fixed SRE practices (golden signals, burn-rate alerting, pillar split). SLO calibration needs judgment but is bounded; escalate via ambiguous-input on contested reliability targets."
+    },
+    "council-review": {
+      "tier": "heavy",
+      "rationale": "Multi-perspective deliberation + weighted reconciliation across distinct expert seats. Cheaper models collapse the seats into one voice and either manufacture or miss the real cruxes. Never downgrade."
+    },
+    "devils-advocate": {
+      "tier": "heavy",
+      "rationale": "Adversarial code review across four lenses. Cheaper models miss edge cases and under-call severity \u2014 the whole value is the hard thinking. Never downgrade."
+    },
+    "output-hygiene": {
+      "tier": "standard",
+      "rationale": "The mechanical pass is a deterministic script; the model does bounded rewriting of flagged prose against a fixed tell list, not adversarial review."
+    },
+    "doc-critique": {
+      "tier": "heavy",
+      "rationale": "Adversarial doc review against rubrics. Same as devils-advocate: the value is catching what a fast pass misses. Never downgrade."
+    },
+    "tech-comparison-matrix": {
+      "tier": "heavy",
+      "rationale": "Weighted multi-criteria judgment with a recommendation. Mis-weighting is the failure mode; heavy is worth it. Never downgrade."
+    },
+    "threat-model": {
+      "tier": "heavy",
+      "rationale": "Adversarial reasoning over a design \u2014 cheaper models emit checklist residue, miss authz/insider paths, and inflate severity. Never downgrade."
+    },
+    "prfaq": {
+      "tier": "standard",
+      "rationale": "Synthesizes a press release and FAQs from a product concept against a fixed format. The specificity discipline needs care but the template bounds it; escalate via ambiguous-input when the concept itself is contested."
+    },
+    "okr-cascade": {
+      "tier": "standard",
+      "rationale": "Structured derivation against a fixed roll-up discipline; the causal-sentence and gap judgments need care but the template bounds them. Escalate via ambiguous-input when the company objectives themselves are contested."
+    },
+    "user-journey-map": {
+      "tier": "standard",
+      "rationale": "Structured synthesis into a fixed four-row stage model plus bounded ranking judgment. Escalate via ambiguous-input when the persona or outcome is contested or research inputs conflict."
+    },
+    "strategy-analysis": {
+      "tier": "heavy",
+      "rationale": "Framework selection plus evidenced multi-factor judgment ending in a ranked, committal verdict. Cheaper models fill cells with generic filler, skip the TOWS crossings, and refuse to take a side. Never downgrade."
+    },
+    "agent-loop-design": {
+      "tier": "standard",
+      "rationale": "Design synthesis against a fixed state-machine pattern and exit-criteria catalog. The gate-placement judgment is bounded by the blast-radius rule; escalate via ambiguous-input when the task itself is contested."
+    },
+    "subagent-design": {
+      "tier": "standard",
+      "rationale": "Design synthesis against a fixed topology catalog and role-card template. The fan-out-or-refuse judgment is bounded by the three-reasons rule; escalate via ambiguous-input on genuinely novel workflow shapes."
+    },
+    "agent-budget": {
+      "tier": "standard",
+      "rationale": "Quantitative spec synthesis against a fixed tier vocabulary and degradation ladder. Cap-setting judgment is bounded by the 3-5x rule; escalate via ambiguous-input when the workflow itself is undefined."
+    },
+    "agents-md-generator": {
+      "tier": "standard",
+      "rationale": "Repo inspection plus synthesis against a fixed section order and line budget \u2014 the same shape as reverse-architecture. The judgment is the counterfactual test on each convention line, which is bounded; escalate via large-input on monorepos."
+    },
+    "agent-threat-model": {
+      "tier": "heavy",
+      "rationale": "Adversarial reasoning over a capability graph \u2014 the judgment is which mitigations are architectural versus theatrical, and that call is exactly where a weaker model produces a confident wrong answer. Never downgraded."
+    },
+    "prompt-caching-advisor": {
+      "tier": "standard",
+      "rationale": "Structural analysis of prompt with threshold arithmetic and pattern matching \u2014 above light, no need for heavy."
+    },
+    "token-budget-estimator": {
+      "tier": "standard",
+      "rationale": "Arithmetic breakdown plus heuristic judgment on dominant cost drivers \u2014 standard fits."
+    },
+    "eval-harness-generator": {
+      "tier": "standard",
+      "rationale": "Reads a SKILL.md and synthesizes eval cases \u2014 requires understanding of skill intent but not heavy reasoning."
+    },
+    "tool-use-schema-writer": {
+      "tier": "standard",
+      "rationale": "Schema generation from natural-language description \u2014 structured output task that fits standard tier."
+    },
+    "contribution-wizard": {
+      "tier": "standard",
+      "rationale": "Intake plus structured generation \u2014 standard tier covers template-filling and schema-adherence judgment."
+    },
+    "ux-writing": {
+      "tier": "standard",
+      "rationale": "Short-form writing to fixed slot rules and character budgets, plus a terminology consistency pass. Bounded generation with clear checks."
+    }
+  }
+}

skilldrop_cli/data/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "skilldrop-cli",
+  "version": "0.16.3",
+  "description": "Portable AI-agent skills, measured against the agent without them. ADRs, PRDs, runbooks, decks and reviews, installable into Claude Code, Cursor, Kiro, and any IDE that takes custom instructions. One command per skill or per role-based pack.",
+  "author": {
+    "name": "Sanjay Ananthanarayan",
+    "url": "https://github.com/sananthanarayan"
+  },
+  "bin": {
+    "skilldrop": "bin/skilldrop.js"
+  },
+  "files": [
+    "bin/",
+    "packs/",
+    "agents/",
+    "contracts/",
+    "catalogue.json",
+    "profiles.json",
+    "model-routing.json",
+    "LICENSE-MIT",
+    "LICENSE-APACHE"
+  ],
+  "engines": {
+    "node": ">=16.7.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "cursor",
+    "kiro",
+    "codex",
+    "ai-agent",
+    "skills",
+    "prompts",
+    "adr",
+    "prd",
+    "runbook",
+    "diagrams"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sananthanarayan/skilldrop.git"
+  },
+  "license": "(MIT OR Apache-2.0)",
+  "homepage": "https://github.com/sananthanarayan/skilldrop#readme"
+}

skilldrop_cli/data/packs/ai-engineering/pack.json

@@ -0,0 +1,57 @@
+{
+  "description": "Adopt and build AI systems: readiness assessment, use-case triage, rollout and acceptable-use policy, plus agent loop design, subagent orchestration, spend budgets, agent security review, eval harnesses, and AI-usage reporting.",
+  "display_name": "AI engineering",
+  "keywords": ["ai-adoption", "agents", "evals", "governance", "budgets"],
+  "links": {
+    "documentation": "https://sananthanarayan.github.io/skilldrop/packs/ai-engineering/"
+  },
+  "maintainers": [
+    {
+      "name": "sananthanarayan"
+    }
+  ],
+  "first-value": {
+    "audience-posture": "non-technical",
+    "prerequisites": [],
+    "starter-task": "Find out whether a team is ready to adopt AI tools, and what blocks it first",
+    "starter-prompt": "Are we ready for AI? Our support team has 12 people on Zendesk, no AI tools today, and a legal team worried about customer data.",
+    "verification": "ai-readiness-assessment scores six dimensions (data, tooling, skills, governance, process, culture) with evidence for each, and ranks the gaps that block adoption first.",
+    "recovery": "If ai-readiness-assessment does not activate, ask for it by name and check that its folder exists in your skills folder (`~/.claude/skills/` by default)."
+  },
+  "requires": ["core"],
+  "journey": {
+    "when": "A team wants to adopt AI tools and needs to know whether it is ready, where to start, what the rules are, and how to roll out.",
+    "you_bring": [
+      "the team or organisation in scope and what the answer will feed (a go/no-go, a budget, a sequence)",
+      "evidence about current tools, data, policies and practices",
+      "the candidate AI use cases",
+      "any regulatory or contractual limits on data"
+    ],
+    "steps": [
+      {
+        "skill": "ai-readiness-assessment",
+        "you_do": "Describe the team, its tools and data, and the concerns already raised.",
+        "you_get": "Scores from 0 to 4 on data, tooling, skills, governance, process and culture, each with an evidence line, the gaps ranked by what blocks first, and a one-sentence posture.",
+        "decide": "Decide whether to go ahead, and at what scope, from the stated posture."
+      },
+      {
+        "skill": "ai-use-case-triage",
+        "you_do": "List the candidate use cases.",
+        "you_get": "A ranked portfolio scored on value, feasibility and risk with the weights shown, one first slice with the observable that proves or kills it, and a not-yet list with promotion conditions.",
+        "decide": "Confirm the first slice."
+      },
+      {
+        "skill": "ai-usage-policy",
+        "you_do": "Give the population, the tools and any data rules already in force.",
+        "you_get": "An acceptable-use policy with three data tiers, permitted and prohibited uses as behaviours, a human-review matrix, approved tools with an exception route, and an owner per section."
+      },
+      {
+        "skill": "ai-adoption-rollout",
+        "you_do": "Name the chosen tool or workflow and who it is for.",
+        "you_get": "A rollout in waves with enablement per cohort, named champions, a comms plan that says what will not change, and an adoption gate on every wave.",
+        "decide": "Each wave's gate must be met before the next cohort opens."
+      }
+    ],
+    "you_end_with": "A readiness baseline, a chosen first use case, a usage policy, and a gated rollout plan."
+  }
+}