Claude Skills by Eliyce

Reconstruct compact session context from canonical handoff artifacts.

Compare a new request against the current spec to classify coverage or conflict.

Run deterministic spec defect analysis before compliance extraction.

Turn scoped work into story and solution artifacts.

For each failing test in the verification evidence, propose the smallest fix anchored to file, line, and acceptance criterion.

Map acceptance criteria to specific verification actions.

Match raw prompts to canonical framework workflows before any pipeline phases begin.

Audit the running UI against WCAG 2.2 A/AA — contrast, focus visibility, keyboard order, ARIA, target size, prefers-reduced-motion. Findings tagged WCAG-2.2.x.x.x.

Verify every component in the AST-derived inventory matches its declared spec in components.md. Flag undocumented variants, !important, inline style=, and unwrapped primitives.

Audit voice, tone, labeling, and information architecture against patterns.md.

Review schema and migration changes for integrity and safety.

Grade the project's design-system contract for completeness and produce a coverage inventory every downstream design-test skill references. Analog of stride-threat-model.

Sync docs/instructions/design-system/* when a token, component, or breakpoint is added to source. Mirror of canonical-doc-sync.

Find and evidence the guards that gate surfaces and transitions — permissions, roles, feature flags, auth and data states — and how each is satisfied, without inventing protection the code does not enforce.

Review and improve indexing strategy for changed data paths.

Propose a small set of capped, well-formed journeys over the verified map — one actor, one goal, ordered evidenced steps, dual ends — all marked proposed for human confirmation, never auto-confirmed.

Adversarially refute or confirm the claims the deterministic checks could not settle — the Tier-B pass over the site map — grounding each verdict in resolving evidence and never rubber-stamping.

Verify animations match motion.md budgets and prefers-reduced-motion is respected.

Analyze query behavior for correctness and performance risk.

Verify declared breakpoints are exercised, no horizontal scroll appears, touch targets meet spec, and RTL parity holds when declared.

Generate a canonical RCA artifact for an incident or failure.

Drive the compile verb that folds the surface, transition, and guard layers into app-map.yaml, and resolve merge conflicts against the locked committed content without overwriting curated entries.

Turn the graph invariants and verification verdicts into stable SM-* findings and a gap report, so the map's problems are triaged, evidenced, and each carry a concrete fix.

Keep the site map fresh during a feature-development change — when a diff touches flow-relevant files, patch just the affected surfaces so the map never drifts from the code it describes.

Grade whether the project is mappable — app kind, frameworks, and an extractor that covers its shape — and route the unmappable case before any other site-map skill runs.

Re-check the stored site map against the current code by running the same verification again — never invent a finding, never soften one, never call the absence of proof a fix.

Verify every component in the AST inventory implements its declared states (default/hover/focus/disabled/loading/error/empty) and is exercised by Playwright tests.

Run the extractors, normalize the raw surfaces, and fingerprint the result so the site-map run has a deterministic, evidence-backed inventory of what the app exposes.

Turn raw extracted surfaces into named, typed, module-attributed surfaces with entry and exit marks — the non-inferable layer the engine cannot derive from the code alone.

Detect hard-coded design values (hex, raw px/rem, ad-hoc font stacks) in UI source that should resolve to a declared token. High severity by default.

Find and evidence the transitions between surfaces — where navigation actually goes, what triggers it, and the file:line that proves it — without inventing edges from mere links.

Maintain UI screens, components, and state docs after UI changes.

Generate or update user flows for UI-facing features.

Research external UI references for full-lane UI work.

Evaluate UI behavior against usability heuristics.

Define interface states and transitions for UI-heavy work.

Suggest regression coverage for changed stack behavior.

Shape a writing task into an outline, brief, sequence, or publishable plan. Use when a content request needs structure (audience, goal, outline, success metric) before drafting.

Review drafts for clarity, structure, evidence quality, and reader usefulness against the project's writing rules. Use when a draft needs a structured review pass before publishing.

Produce reader-ready drafts for docs, briefs, landing pages, and internal writing deliverables, starting from a brief and ending in style-compliant prose. Use when an approved brief needs to become a publishable draft.

Write concise spoken-word scripts and narrative sequences optimized for pacing, transitions, and spoken clarity. Use when the deliverable will be performed aloud (video, podcast, demo).

Revise drafts for search visibility — keyword placement, heading hierarchy, meta fields, internal links — without sacrificing readability. Use after the draft is reader-ready and before publishing.

Normalize drafts to the project's explicit writing style and formatting rules at docs/instructions/rules/writing-style.md. Use as the last pass before publish.

Reason about authentication weaknesses including JWT vulnerabilities, session security, OAuth/OIDC flaws, brute-force surfaces, and password storage from code and docs evidence.

Derive abuse cases from module docs and validate them against tests and runtime evidence.

Identify cryptographic failures including weak hashing, insecure encryption modes, hardcoded keys, weak PRNG usage, and disabled TLS verification from code evidence.

Normalize dependency advisories across native audits and OSV evidence.

Reason about SSRF, IDOR, mass assignment, injection vectors, file upload abuse, prototype pollution, and ReDoS from code and docs evidence.

Assess security logging and monitoring gaps including missing audit trails, log injection surfaces, sensitive data in logs, and alerting coverage.

Review authorization, tenant isolation, and privileged route boundaries.