specialist-knowledge

Included with Lifetime

$97 forever

Summon, cache, and apply a distilled "specialist profile" — the load-bearing craft of a domain expert (native iOS design, high-performance React Native, Expo idioms, accessibility, animation) — instead of emitting generic, stale advice from memory or hand-authoring a new skill per specialty. Use this BEFORE building in a domain that needs specialist taste, when a screen or module must feel native, be high-performance, or follow platform conventions, and whenever the model would otherwise produce plausible-but-mediocre output from its priors. It keeps a repo-local store (specialist-profiles.jsonl): per domain, the load-bearing principles, the anti-patterns a master avoids, a review checklist, the authorities confirmed against, the library versions it is pinned to, the user-taste deltas, and the date. Look up a profile to apply it cheaply; distill or refresh one by confirming against authority AND adjudicating contested taste with the user. Twin of library-knowledge: facts there, craft here.

Designscripts

What this skill does


# Specialist Knowledge

The craft shelf — the twin of `library-knowledge`. That skill caches a domain's
**facts** (what version, what API, what capability). This one caches a domain's
**craft** (what a master *does* — the idioms, taste, and performance patterns
that make iOS feel native or RN run at 60fps).

It exists because the model's priors for craft are **generic and stale**: asked
to "make it native" from memory, it produces the plausible-but-mediocre average
of its training data — the generic-AI-aesthetic problem. And hand-authoring a
skill per specialty (`ios-specialist`, `rn-perf-specialist`, …) is the
*duplication* failure at the meta level, plus speculative pre-building for
platforms you may never touch. So this skill is **not** the expertise. It is a
**distiller**: a repeatable procedure that summons a specialist's soul on
demand, confirmed against authority, adjudicated for taste with you, and cached
as a small reusable profile.

The value: **distill once (confirm authority + adjudicate taste), cache, apply
many times cheap, refresh only on drift.**

## Why a separate boundary from library-knowledge

Both are external truth-sources the agent can't fill from priors; both
confirm-cache-reconfirm. The difference that earns a separate skill: library
facts are **verifiable and single-sourced** (the docs say RN is 0.85, period),
so they need no human. Craft is **contested and partly subjective**, so *you*
are a first-class truth-source — the way you are at the spec parse-point. This
skill is the synthesis of the harness's two existing external boundaries: it
confirms against authority like library-knowledge, and it adjudicates taste with
you like the skeleton's spec gate.

## The store entry (the interface)

`specialist-profiles.jsonl` at the repo root — one self-describing record per
line (JSONL), keyed by `domain` (e.g. `ios-native-design`,
`high-performance-react-native`, `expo`):
- `principles` — the load-bearing few, not an encyclopedia. The compressed soul.
- `anti_patterns` — what a master *avoids* (often more diagnostic than the do's).
- `checklist` — the review questions to apply at skeleton/build time.
- `authorities` — the sources confirmed against (e.g. Apple HIG, RN/Expo perf docs).
- `pinned_libs` — the library-knowledge entries + versions this craft is bound to.
  **This is the seam:** craft references facts so it never drifts from the real
  API surface. `[email protected]`, `expo@56` — if those bump, the profile is stale.
- `taste_deltas` — the user-adjudicated, app-specific judgments (contested calls).
- `confirmed_on` — provenance + the staleness clock.

## Workflow

- **Apply (cheap, the common path):** `specialist_lookup.py --domain <d>` returns
  one profile's principles + checklist for use at STAGE 0.5 / build. Stale or
  missing → distill/refresh first. Never emit craft advice from memory when a
  profile exists.
- **Distill (expensive, effectful, rare):** when a domain is first needed or has
  gone stale, run the distillation procedure (see `references/distilling.md`):
  scope the specialist → confirm current authority (web, pinned to
  library-knowledge versions) → **adjudicate contested taste with the user** →
  compress to load-bearing principles + anti-patterns + checklist → cache.
  Record via `specialist_refresh.py --set <domain> --from-json <file>`.
- **Refresh on drift:** `specialist_refresh.py --check` flags a profile whose
  `pinned_libs` no longer match library-knowledge, or that the user says is out
  of date. Refresh is a diff, not a relearn.

## Composition (how it plugs into the harness)

- Profiles are **applied at STAGE 0.5 and build** (feature-workflow): the
  checklist becomes review questions; the principles shape the implementation.
- `pinned_libs` is queried against **library-knowledge** — the facts/craft seam.
- Profiles are **inherited**: the tenth iOS screen summons nothing, it reuses the
  cached soul. Craft-elicitation cost slopes down like spec cost does.
- The **knowledge-ratchet** governs graduation: a recurring specialist correction
  climbs the ladder (ad-hoc → cached profile → convention/lint). A profile
  graduates to its *own dedicated skill* only on the VENDOR cost test — when the
  federation truly needs it — so the federation surface stays controlled instead
  of sprouting one skill per platform.

## The one law, here

A profile is **craft, not facts, not spec**: keep version facts in
library-knowledge (referenced via `pinned_libs`), product intent in the spec
(skeleton invariants), and only the *taste and technique* here. One profile, one
domain's soul — small enough to stay load-bearing, pinned enough to stay honest.

## Files
- `references/distilling.md` — the distillation procedure (how to render a soul).
- `scripts/store.py` — the storage port (JSONL; the only module touching disk).
- `scripts/specialist_lookup.py` — apply a profile cheaply (one entry / index).
- `scripts/specialist_refresh.py` — distill/record a profile; `--check` staleness
  vs library-knowledge.

Files: 5

Size: 22.7 KB

Complexity: 61/100

Category: Design

Source: https://github.com/pproenca/dot-claude/tree/main/plugins/cairn/skills/specialist-knowledge

Related in Design

contribute

Included

Local-only OSS contribution command center. Auto-refreshes the user's in-flight PR and issue state on invoke so conversations start with full context — no need to brief Claude on what's in flight. Helps the user find issues to contribute to on GitHub, builds per-repo dossiers of what each upstream expects (CLA, DCO, branch convention, AI policy, draft-first, review bots, issue templates), runs deterministic gates before any external action so AI-assisted contributions don't reach maintainers as slop. State is markdown-only: candidate files at ~/.contribute-system/candidates/, repo dossiers at ~/.contribute-system/research/, append-only event log at ~/.contribute-system/log.jsonl. No database, no cloud calls. Use when the user asks about their PRs / issues / contributions, wants to find new work to take on, claim an issue, build/refresh a repo's dossier, or draft a Design Issue or PR. Trigger with "/contribute", "what's my PR status", "find a contribution", "claim issue X", "draft a Design Issue for Y", "refresh dossier for Z".

Designscripts

architectural-analysis

Included

User-triggered deep architectural analysis of a codebase or scoped subtree across eight modes — information architecture, data flow, integration points, UI surfaces, interaction patterns, data model, control flow, and failure modes. This skill should be used when the user asks to "diagram this codebase," "map the architecture," "show the data flow," "give me an ERD," "trace control flow," "find the integration points," "verify the layout pattern," "audit the UX architecture," or any similar request whose primary deliverable is mermaid diagrams plus cited reports under docs/architecture/. Dispatches haiku/sonnet sub-agents in parallel for per-mode exploration, then verifies every citation mechanically before any node lands in a diagram. Not for one-off prose explanations of code (use code-explanation) or for high-level system design from scratch (use system-design).

Designscripts

mcp

Included

Model Context Protocol (MCP) server development and tool management. Languages: Python, TypeScript. Capabilities: build MCP servers, integrate external APIs, discover/execute MCP tools, manage multi-server configs, design agent-centric tools. Actions: create, build, integrate, discover, execute, configure MCP servers/tools. Keywords: MCP, Model Context Protocol, MCP server, MCP tool, stdio transport, SSE transport, tool discovery, resource provider, prompt template, external API integration, Gemini CLI MCP, Claude MCP, agent tools, tool execution, server config. Use when: building MCP servers, integrating external APIs as MCP tools, discovering available MCP tools, executing MCP capabilities, configuring multi-server setups, designing tools for AI agents.

Designscripts

react-native-skia

Included

Design, build, debug, and optimise high-polish animated graphics in React Native or Expo using @shopify/react-native-skia, Reanimated, and Gesture Handler. Use when the user wants canvas-driven UI, shaders, paths, rich text, image filters, sprite fields, Skottie, video frames, snapshots, web CanvasKit setup, or performance tuning for custom motion-heavy elements such as loaders, hero art, cards, charts, progress indicators, particle systems, or gesture-driven surfaces. Also use when the user asks for fluid, glow, glass, blob, parallax, 60fps/120fps, or GPU-friendly animated effects in React Native, even if they do not explicitly say "Skia". Do not use for ordinary form/layout work with standard views.

Designscripts

plaid

Included

Product Led AI Development — guides founders from idea to launched product. Six capabilities: Idea (discover a product idea), Validate (pressure-test the idea against fatal flaws, problem reality, competition, and 2-week MVP feasibility), Plan (vision intake + document generation), Design (translate image references into a design.md spec), Launch (go-to-market strategy), and Build (roadmap execution). Use when someone says "PLAID", "plaid idea", "help me find an idea", "product idea", "idea from my business", "idea from my expertise", "plaid validate", "validate my idea", "pressure-test", "is this idea good", "find fatal flaws", "validate the problem", "plan a product", "define my vision", "generate a PRD", "product strategy", "plaid design", "design from image", "translate image to design", "create design.md", "extract design tokens", "plaid launch", "go-to-market", "launch plan", "GTM strategy", "launch playbook", "plaid build", "build the app", "start building", or "execute the roadmap".

Designscripts

nextjs-framer-motion-animations

Included

Adds production-safe Motion for React or Framer Motion animations to Next.js apps, including reveal, hover and tap micro-interactions, whileInView, stagger, AnimatePresence, layout and layoutId transitions, reorder, scroll-linked UI, and lightweight route-content transitions. Use when the user asks to add, refactor, or debug Motion or Framer Motion in App Router or Pages Router codebases, especially around server/client boundaries, reduced motion, LazyMotion, bundle size, hydration, or route transitions. Avoid for GSAP-style timelines, WebGL or 3D scenes, heavy scroll storytelling, or CSS-only effects unless Motion is explicitly requested.

Designscripts