jpoindexter

Use when a conversation is getting long, drifting, juggling multiple tasks, re-pasting the same files, or showing stale/confused context — and at the start of any new task. Triggers: long thread, context bloat, topic switch, repeated file uploads, 'why is it forgetting', degraded answers, finished one task and starting another.

Use when a user wants to deconstruct a complex problem, business challenge, product decision, strategy question, career crossroads, or stuck situation by stripping assumptions, identifying first principles, rebuilding options from foundational truths, and choosing one high-leverage action.

Audit role-based access control and permission drift across product surfaces.

Add a new feature to an existing @fabrk/* package following monorepo conventions

Build or rebuild the ADR index and dependency graph in AgentDB

Query AgentDB with semantic routing, hierarchical recall, causal graphs, and context synthesis

Use when the user wants to reduce AI coding spend without reducing shipping speed. Covers model routing, prompt caching, context discipline, loop profiling, and rollout plans for Cursor, Claude Code, Aider, and similar coding-agent stacks.

When the user wants to optimize content for AI search engines, get cited by LLMs, or appear in AI-generated answers. Also use when the user mentions 'AI SEO,' 'AEO,' 'GEO,' 'LLMO,' 'answer engine optimization,' 'generative engine optimization,' 'LLM optimization,' 'AI Overviews,' 'optimize for ChatGPT,' 'optimize for Perplexity,' 'AI citations,' 'AI visibility,' 'zero-click search,' 'how do I show up in AI answers,' 'LLM mentions,' or 'optimize for Claude/Gemini.' Use this whenever someone wants their content to be cited or surfaced by AI assistants and AI search engines. For traditional technical and on-page SEO audits, see seo-audit. For structured data implementation, see schema-markup.

Scan dependencies for known CVEs across ecosystems — npm audit, cargo audit, osv-scanner (multi-ecosystem, catches what npm audit misses), pip-audit. Triage by reachability (runtime vs dev) and severity before mass-bumping.

Static application security testing of YOUR code (not deps) — semgrep with the security rulesets, CodeQL for deeper dataflow. Find injection, path traversal, unsafe exec, hardcoded crypto. Triage false positives by tracing reachability, don't blanket-ignore.

Find committed secrets before they ship. gitleaks over full history + staged, Vanta's own secret-scan, plus the remediation order (rotate FIRST, then scrub). Run before any repo goes public or any release tag.

The composed security gate before going public or cutting a release: secret-scan + dependency-audit + sast-scan, in order, with a clear pass/triage report. The security sibling of ship-preflight — refuses to wave through unrotated secrets or shipped-runtime CVEs.

Use when generating ideas, framing a problem, breaking a fixation, or validating a plan and you want ONE deliberate creative method instead of generic brainstorming. Routes a problem's signals (phase / domain / specificity / feasibility↔creativity balance) to ONE of 22 named methods from artists, scientists, and designers — Eno, Dalí-adjacent Jarry, Cage, de Bono, Pólya, Alexander, Meadows, Vonnegut, Tharp and more — and runs its procedure. Backed by a deterministic, tested router (src/solutioning/ideation.ts), so the choice is reproducible, not vibes. Feeds the solutioning / cofounder pillar.

Build or update an organized operator profile in Vanta's brain so Vanta can draft in the operator's voice, review documents and websites to their standard, and recommend purchases by their criteria. Gathers ONLY from authorized sources (Vanta brain/memory, mounted vault, files the operator names, public web, the live conversation), self-scores sufficiency against those three goals, and saves to the user_model brain region. NEVER stores IDs, payment data, passwords, tokens, or secrets. Use when the operator says "learn about me", "build my profile", "remember everything about me", or asks Vanta to write in their voice or review to their standard.

Pre-deploy gate: typecheck (must exit 0) -> full test suite (all pass) -> build. Any red = stop and report which gate failed. Green = print the deploy command, never run it.

4-phase root cause debugging: understand bugs before fixing.

Apply Tufte's Chapter 9 + Epilogue principles for the visual craft of a finished data graphic — the qualities of attractive displays, friendly vs unfriendly graphics, horizontal proportion and the golden rectangle, thin-line copper-plate craft, words/numbers/drawing integration, format selection, and the thesis that beauty is a by-product of clarity and data complexity. Use when judging or refining the look and technique of a graphic, not its data integrity or chartjunk count.

The six principles of analytical design from Beautiful Evidence — how to build evidence presentations that assist reasoning rather than decorate reports, why those principles are universal (from the first stone map to any future display), and how to distinguish analytical from decorative design.

How to design graphics that demonstrate causality rather than mere correlation, drawn from Tufte's analysis of the Snow cholera map and the Challenger O-ring disaster; use when building or critiquing any display whose purpose is to support a causal claim or policy decision.

Identifies and eliminates the three categories of chartjunk — vibrations, grids, and ducks — graphic activity that consumes ink, area, and attention while communicating no data. Use when auditing or designing any chart, dashboard, or data graphic for visual noise.

Tufte's analysis of how PowerPoint's bullet-and-slide format degrades analytical reasoning — the named deficiencies, the bullet list's three-relationship limit, density and pairwise-comparison thresholds, the Columbia case study, and the written-report/4-pager remedy — for use when designing, reviewing, or replacing any slide deck or analytical presentation.

Apply Tufte's principles for color in data graphics — the four functional uses, color's three dimensions, Imhof's four rules, palette strategy, contextual effects, and redundant coding — to maximize information density while minimizing color damage.

Covers Tufte's dual principle of data density AND data-matrix size (VDQI ch.8, pp.161-176) — the formulas, the typographic-density yardstick, empirical benchmarks across 21 publications, the Shrink Principle, three viewing depths, multifunctioning elements, small multiples, and the supertable — for designing, evaluating, or critiquing any statistical graphic.

Apply Tufte's data-ink ratio to strip non-data ink and redundant data ink from statistical graphics — through the two-pass erasure procedure, graphical redesign, and converting frame/tick ink into data — so the largest possible share of ink carries information.

Accessibility foundations for design engineers — WCAG / POUR, semantic-HTML-first then ARIA, keyboard and focus management, inclusive design for permanent/temporary/situational constraints. Use when building or reviewing any interactive UI, adding ARIA, implementing modals/menus/forms, or auditing keyboard operability and focus order.

AI-native design engineering patterns — generative/adaptive UI, streaming as interaction, prompt-as-interface, human-in-the-loop / agentic UX, eval-driven development, designing for uncertainty, latency and cost as design constraints. Use when designing any AI/LLM-powered feature, building agentic or chat UX, handling streaming/probabilistic output, or planning for model error and cost.

Cognitive Load Theory for interfaces — intrinsic (task difficulty), extraneous (poor-design overhead), and germane (useful mental-model building) load. Use when a screen feels overwhelming, deciding what to simplify vs preserve, chunking complex flows, or diagnosing whether friction comes from the task or the design.

Foundational design-engineering principles that govern where complexity lives and how interfaces stay fast and consistent — Tesler's Law, progressive disclosure, progressive enhancement, recognition over recall, optimistic UI, perceived performance, single source of truth, constraints as a feature. Use when deciding system architecture vs UI exposure, reducing user-facing complexity, choosing what to render/reveal, or justifying a constraint-driven system.

CSS and styling architecture — scaling methodologies (BEM, ITCSS, CUBE CSS) and fluid/responsive technique (mobile-first, clamp() fluid type/space, container queries for component-level responsiveness). Use when structuring stylesheets at scale, choosing a CSS methodology, building responsive layouts, or deciding between media queries and container queries.

Design system depth beyond "tokens are data" — three-tier token architecture (primitive → semantic → component), W3C DTCG format and tooling, scales as systems, component API design, headless/unstyled primitives, documentation as product, governance and versioning. Use when architecting a design system, structuring tokens, designing component APIs, choosing headless primitives, or setting up contribution/versioning.

Product discovery and validation frameworks — Jobs To Be Done, Continuous Discovery / Opportunity Solution Tree, Lean UX / Build-Measure-Learn, Design Sprint, Working Backwards, Story Mapping, Crazy 8s. Use when scoping what to build, validating an idea before committing, structuring user research, or turning a fuzzy outcome into testable solutions.

Gestalt principles of grouping — proximity, similarity, common region, continuity, closure, figure/ground, common fate, prägnanz, uniform connectedness. The visual logic behind how the eye assembles elements into wholes. Use when laying out a screen, deciding what reads as related, designing cards/sections, or diagnosing why a layout feels disorganized.

Route product-management work to the smallest relevant set of operational PM skills. Use when the user invokes /pm, asks a broad or ambiguous product question, needs help choosing a PM method, or requests discovery, strategy, positioning, pricing, metrics, experiments, prioritization, roadmaps, requirements, launch, stakeholder, AI-product, or product-review work.

Design an AI-product evaluation system connecting task quality, user outcomes, failure taxonomies, datasets, human judgment, automated checks, release thresholds, and production monitoring. Use when defining AI quality, comparing models or prompts, deciding launch readiness, or diagnosing regressions.

Decide whether a product problem should use AI and define the appropriate human-AI workflow. Use when a team starts with a model or agent idea, must compare AI with deterministic software or process change, needs an AI use-case brief, or must assess data, uncertainty, value, feasibility, cost, and fallback fit.

Review AI-product safety, reliability, privacy, security, fairness, uncertainty, human oversight, fallback, monitoring, drift, latency, and cost risks. Use for AI launch gates, agent actions, high-impact automation, incident preparation, production failure analysis, or system feasibility review.

Discover and validate product opportunities before committing to delivery. Use when a team has feature requests but weak problem evidence, needs to identify customer opportunities, must reduce value or usability risk, or wants a continuous discovery plan tied to an outcome.

Design the smallest reliable experiment or assumption test capable of changing a product decision. Use when the user has a hypothesis, wants an A/B test or prototype test, needs causal evidence, must choose an evidence standard, or wants success, guardrail, stop, and interpretation rules.

Plan, conduct, or analyze non-leading customer interviews that produce behavioral evidence. Use when the user needs an interview guide, wants to evaluate interview notes, must distinguish signal from compliments or hypothetical intent, or needs a recruiting and synthesis plan.

Plan or review a product launch, staged rollout, adoption loop, readiness gate, and post-launch learning plan. Use when a team must decide whether to release, how to sequence exposure, what messaging and support are required, or how to measure adoption, retention, reliability, and rollback.

When the user wants help naming or renaming a company, product, app, or brand. Also use when the user says 'help me name this,' 'generate company names,' 'evaluate these names,' 'rename the company,' 'our name is too generic,' 'score these finalists,' 'we need a better brand name,' or wants a structured naming process instead of a raw brainstorm. Use this to run a naming sprint that maps category conventions, finds the deeper benefit, generates broad candidate territory, and evaluates finalists for distinctiveness, fluency, energy, and longevity.

When the user wants to create, plan, or ship postable organic social content — short-form video, UGC, image + caption, carousels, trend-jack posts, platform-native content packs, or repurposing bundles — for any connected social channel. Triggers include 'post about X', 'make content for Y', 'create a video/reel/short', 'trend-jack Z', 'schedule a post', 'organic content', 'UGC', 'social video', 'reel', 'TikTok', 'hook', 'caption variations', 'generate social creative', 'content calendar', 'weekly posts', 'multi-platform', 'platform-native', 'turn this into posts', 'repurpose this for social'. Use whenever the goal is organic engagement rather than paid conversion — for paid ad creative use ad-creative; for landing page copy use copywriting.

Use when a Vercel build or deployment fails. Covers inspecting build logs, triaging common failure causes (missing env vars, lockfile mismatches, TypeScript/lint errors, wrong framework config, project/team mismatch), and the secure credential flow for missing Stripe or database secrets. Trigger on Vercel build errors, deploy failures, or when the user reports a broken deployment.

Use before starting implementation work in a managed coding-agent sandbox. Covers the repository checkout, branch constraints, already-warmed dev server/GIC browser setup, browser verification, commit/push timing, default PR ownership, and final handoff evidence.

Use when the user asks to create, redesign, preview, or install a favicon, browser tab icon, app icon set, or favicon pack for a website or generated app, including prompt-only requests with no reference image such as 'make me a pack of favicons'.

Use this skill for finance operations inside superoptimizers. Trigger on requests involving collections, billing review, failed payments, dunning, refunds, credits, month-end close, export packs, accounting handoff, finance inbox triage, or recurring finance briefs. This skill is optimized for the managed and already-connected tools that exist in this codebase instead of asking the user to assemble a brand-new finance stack.

Use this bundled GIC coding skill for platform-managed implementation playbooks that require code-aware planning or direct repository coding. It consolidates the prior coding-oriented default skills into one shared guide for site rollout, analytics instrumentation, schema markup implementation, Vercel Workflows implementation, and Stripe billing scaffolding.

Use this bundled GIC skill for the platform-managed non-coding playbooks that power default product, marketing, SEO, support, and Engineer payments workflows. It consolidates the prior individual default skills into one shared router with grouped sections for context, brand/design direction, messaging, experiments, SEO, launch planning, repurposing, support, and Stripe planning. Reach for this skill first when a default GIC agent needs strategy, analysis, or planning before handing implementation to repository coding tools.

Use when tempted to say "I'm being objective", when attributing others' views to bias while trusting your own introspection, or after learning about a bias and concluding it doesn't apply to you. Applies Pronin, Lin & Ross (2002) — the bias blind spot and the introspection illusion.

Use when stating confidence ("I'm sure", "definitely", "99%"), giving confidence intervals, making probabilistic claims, or reviewing a track record of predictions. Applies overconfidence calibration research (Lichtenstein & Fischhoff; Alpert & Raiffa) — subjective certainty systematically exceeds accuracy.

Use before deleting code, removing a check, simplifying a process, dropping a config flag, or removing anything that "serves no purpose" — especially in unfamiliar or legacy systems. Applies Chesterton's Fence (G.K. Chesterton, 1929): don't remove it until you know why it's there.

Use when evidence seems to confirm an existing belief, when research keeps agreeing with the hypothesis, when interpreting ambiguous data, or when a first explanation feels satisfying. Applies Lord, Lepper & Preston (1984) — the one debiasing instruction shown to work: consider the opposite.

Use when writing docs, error messages, onboarding, tutorials, API designs, UX copy, or teaching — or when something you built seems self-explanatory. Applies the curse of knowledge (Camerer, Loewenstein & Weber 1989; Newton's tappers-and-listeners 1990): expertise makes you unable to simulate not-knowing.

Use when operating in an unfamiliar domain, when something "looks right" but hasn't been verified, when confidence is high without external checks, or when evaluating one's own competence at a task. Applies Kruger & Dunning (1999) — the skills needed to perform are the skills needed to judge performance.

Use when testing a hypothesis, debugging, validating a fix, designing experiments or test suites, or when checks keep passing. Applies Popper's falsification and Wason's 2-4-6 task — a test that can't fail isn't a test, and confirming instances prove little.

Use when a problem is stuck when approached directly, when defining success criteria, when designing for reliability/safety, or when a goal is vague ("make it good"). Applies Jacobi's inversion as practiced by Charlie Munger — solve problems backward: avoid the failure instead of chasing the success.

Use when designing, building, or reviewing any AI chat, assistant, copilot, or agent interface — composer, streaming responses, tool-use display, citations, regenerate/edit, or AI empty states. Also fires when users report the AI feeling frozen or opaque about what it's doing or can see, or when wiring confirmations before an agent takes consequential actions.

Use when designing, building, or reviewing any authentication surface — signup, login, logout, magic links, passkeys, OAuth/SSO buttons, password reset, 2FA/MFA, email verification, or session-expiry handling. Also use when users report being locked out, duplicate accounts from mixed auth methods, confusing reset emails, or drop-off on the signup/login screen.

Use when designing, building, or reviewing any checkout, cart, payment, or purchase flow — e-commerce carts, one-off purchases, donation forms, in-app buying. Also use when users report cart abandonment, payment errors losing form state, forced account creation complaints, or confusion about order status after paying.

Use when designing or reviewing any screen that can show no data or is waiting on data — first-use empty states, cleared/zero-result states, error states, loading indicators, skeleton screens, spinners, or optimistic updates. Also use when users report the app 'feels slow', a screen appears blank or janky before content arrives, or a list/search/inbox has nothing to show.

Use when designing or reviewing error states, failure recovery, offline behavior, destructive-action protection, or 404/500 pages — or when users report lost work, confusing error messages, accidental deletions, or dead-end failures. Also fires when choosing between toast, banner, inline, or full-page error display, or wiring retry logic the user can see.

Use when designing, building, or reviewing any form, signup, checkout, settings page, or multi-step wizard — or when users abandon forms, report confusing errors, or lose data navigating back. Also fires when deciding field count, label placement, validation timing, required-field marking, or whether to split a form into steps.

Use when designing or reviewing an app's navigation architecture — choosing between tab bar, sidebar, top nav, or command palette; deciding menu depth vs breadth; or when users report getting lost, can't find features, or the back button behaves unexpectedly. Also applies when adding breadcrumbs, deep links, or restructuring an information hierarchy.

Use when designing, building, or reviewing pricing pages, paywalls, free trials, subscription upgrade/downgrade flows, cancellation flows, or win-back campaigns. Also use when users report trial-to-paid conversion problems, surprise-charge complaints, App Store subscription rejections, or when auditing for dark patterns and ROSCA and state click-to-cancel compliance.

iOS accessibility applied — Dynamic Type (built-in styles + AX1–AX5 sizes, @ScaledMetric, custom-font relativeTo, AX5 testing), VoiceOver (labels/values/hints/traits, element grouping, reading order, rotor, decorative hiding), color & contrast (WCAG AA 4.5:1/3:1, Increase Contrast, Differentiate Without Color, never color-only), 44pt touch targets, motion/transparency settings, alternative input (Voice Control/Switch Control/Full Keyboard Access), and auditing (Accessibility Inspector + performAccessibilityAudit). Use when building, reviewing, or auditing the accessibility of any native iOS/SwiftUI screen.

iOS app icon + App Store presence applied — the icon design grid (single focal mark, no words, full-bleed, no baked mask), the iOS 26 Icon Composer layered/Liquid Glass system (light/dark/tinted/clear from one 1024 master), current App Store Connect screenshot device sizes + counts, app preview video specs, and product-page metadata character limits (name 30 / subtitle 30 / keywords 100 / promo 170), plus honest ASO. Use when designing an app icon, packaging App Store screenshots/metadata, or planning a product page.

iOS Swift Charts applied — picking the right mark for the intent (trend→line/area, comparison→bar, composition→stacked/sector, single value→Gauge/ring), the Chart + Mark / axis / scale / interactivity APIs, the zero-baseline honesty rule, charts-that-animate-on-data-change, the SwiftUI Gauge and custom-arc ring, and free + hand-authored chart accessibility (auto AX tree, AXChartDescriptor, Audio Graphs). Use when adding, choosing, or reviewing any chart or data visualization on a native iOS screen.

iOS semantic system colors, dark mode, and material levels per Apple HIG (iOS 26 shipping baseline; iOS 27 / WWDC 2026 current cycle). Covers why you never hard-code system color values, the system vs grouped background sets, label/separator colors, dark mode base-vs-elevated + the 4.5:1/7:1 contrast floors, the four standard material levels + vibrancy, Liquid Glass color rules (incl. the iOS 27 v2 material tuning + user transparency slider), and Display P3. Use when choosing colors, backgrounds, or materials for any native iOS screen.

Apple HIG component rules for native iOS 26 — bars (tab/nav/toolbar/search incl. floating + concentric corners), buttons (44pt hit region, prominence, roles, no destructive-primary), menus/pull-down/pop-up, toggles/pickers/segmented/sliders/steppers/text fields, lists & tables, sheets + detents, alerts vs action sheets vs popovers, modality, progress/gauges, with the SwiftUI mapping. Use when choosing or reviewing any iOS control or presentation.

Apple HIG behavioral patterns for native iOS — onboarding, launch screens, loading, modality decisions, feedback, settings, search, privacy & permission flows (purpose strings, priming screens, ATT), account deletion, in-app purchase, ratings, notifications — plus motion/reduce-motion, haptics (UIFeedbackGenerator patterns), and the accessibility floors (contrast AA, touch targets, Dynamic Type 200%, VoiceOver). Use when designing any flow, permission prompt, empty/loading state, or feedback moment on iOS.

iOS gestures and haptics applied — the standard system gestures (tap, long-press, swipe, pan, pinch, rotate, edge-swipe back) and the rule never to override them, the SwiftUI gesture APIs (.onTapGesture / LongPressGesture / DragGesture / MagnifyGesture / RotateGesture and composing them) plus the row-level affordances (.swipeActions, .contextMenu, .draggable/.dropDestination, .refreshable), and the haptics stack — the three UIFeedbackGenerator families (impact / notification / selection), Core Haptics for custom patterns, and SwiftUI .sensoryFeedback(_:trigger:) — with HIG best practices. Use when adding any gesture, swipe action, or haptic to a native iOS screen.

iOS layout & spacing for iPhone — the 8pt grid convention + 4pt sub-grid, real Apple layout numbers (16/20pt system margins, safe-area insets, 44/49/50pt bar heights), the 44pt touch target, building dense low-scroll layouts with LazyVGrid/Grid + GridItem (2-up/3-up rules), SwiftUI's adaptive default spacing, and the iOS 26 floating-chrome layout model. Use when laying out any iPhone screen, choosing margins/gutters, or building a grid.

Use when the user invokes /design, or asks to design/build/audit/polish any web or cross-platform UI — screen, component, layout, table, chart, form, color system — and it's unclear which design reference skills apply. Dispatcher that routes to the right 2-4 companion skills (components-and-states, layout-and-composition, color-and-elevation, data-visualization, ...) instead of loading the whole family. Native iOS work routes to /ios instead.

Use when the user invokes /ios, or when starting ANY native iOS/SwiftUI screen, component, flow, or review and it's unclear which ios-* skills apply. Dispatcher that routes to the right 2-4 companion ios-* reference skills instead of loading the whole family or designing from memory.

iOS semantic system colors, dark mode, and material levels per Apple HIG (current iOS 26). Covers why you never hard-code system color values, the system vs grouped background sets, label/separator colors, dark mode base-vs-elevated + the 4.5:1/7:1 contrast floors, the four standard material levels + vibrancy, Liquid Glass color rules, and Display P3. Use when choosing colors, backgrounds, or materials for any native iOS screen.

Apple HIG component rules for native iOS 26 — bars (tab/nav/toolbar/search incl. floating + concentric corners), buttons (44pt hit region, prominence, roles, no destructive-primary), menus/pull-down/pop-up, toggles/pickers/segmented/sliders/steppers/text fields, lists & tables, sheets + detents, alerts vs action sheets vs popovers, modality, progress/gauges, with the SwiftUI mapping. Use when choosing or reviewing any iOS control or presentation.

Apple HIG behavioral patterns for native iOS — onboarding, launch screens, loading, modality decisions, feedback, settings, search, privacy & permission flows (purpose strings, priming screens, ATT), account deletion, in-app purchase, ratings, notifications — plus motion/reduce-motion, haptics (UIFeedbackGenerator patterns), and the accessibility floors (contrast AA, touch targets, Dynamic Type 200%, VoiceOver). Use when designing any flow, permission prompt, empty/loading state, or feedback moment on iOS.

iOS layout & spacing for iPhone — the 8pt grid convention + 4pt sub-grid, real Apple layout numbers (16/20pt system margins, safe-area insets, 44/49/50pt bar heights), the 44pt touch target, building dense low-scroll layouts with LazyVGrid/Grid + GridItem (2-up/3-up rules), SwiftUI's adaptive default spacing, and the iOS 26 floating-chrome layout model. Use when laying out any iPhone screen, choosing margins/gutters, or building a grid.

iOS 26 Liquid Glass design language + the SwiftUI APIs that implement it, sourced from Apple's WWDC25 sessions 219/323 and developer.apple.com. Covers the functional-layer-over-content mental model, regular vs clear variants, glass-on-glass/over-tint don'ts, the floating tab bar, scroll edge effects, concentric corners, accessibility behavior, and a verified-vs-community API table. Use when building or reviewing any iOS 26 native screen's chrome, materials, or glass effects.

SF Symbols usage (weights, scales, the four rendering modes, fill-vs-outline variants, animations, SF Symbols 7 gradients/Draw, accessibility labels, version-gating) and iOS 26 app icons (layered design, Icon Composer, square-unmasked layers, the six appearances, specs) per Apple HIG. Use when picking icons, choosing rendering modes, or producing an app icon for a native iOS app.

Use when setting up a project's structure, or when the agent needs the stack, folder layout, data flow, schemas, and the hard boundary rules it must never cross. Use when code keeps crossing layers (UI logic in API routes, DB calls in components).

Use when planning what to build and in what order — splitting a project into sequenced, scoped feature phases so the agent never has to decide "what's next" on its own. Use when work feels like random feature-hopping.

Use when establishing or enforcing how code is written in a project — naming, conventions, file structure, error handling — so the agent stays consistent across sessions instead of drifting into its own style by week two.

Use when a project depends on third-party libraries and the agent needs project-specific usage rules — and must check for an MCP server or current docs — before coding against a library it only half-remembers.

Use when tracking build progress across sessions — a living checklist updated as features complete, so a new session knows exactly where work left off without re-explaining.

Use when starting a new project, or when the agent lacks a clear picture of what's being built, who it's for, and what is explicitly out of scope. Use when a build keeps producing things nobody asked for.

Use when tracking which UI components exist and their exact classes, so the agent reuses components instead of rebuilding divergent ones. The living index maintained alongside the imprint skill.

Use when defining how a product's UI looks and behaves — layout, cards, buttons, badges, typography — so every page feels like one product instead of the agent inventing a new style each session.

Use when you need a real-world brand-identity precedent to justify a recommendation, cite a comparable project, or diagnose what made an identity succeed — e.g. a rebrand honoring heritage/equity, localizing or naming for a new market, differentiating from a parent company, launching a new company or category, unifying a fractured multi-touchpoint ecosystem, or building a dynamic/flexible system.

Use when accounting for contemporary forces on a brand — social justice stances, sustainability/triple bottom line, going global or localizing, AI in the workflow, big-data analytics, social media strategy, digital/AR/VR interfaces, mobile app icons, evidence-based marketing, private-label architecture, brand licensing, certification symbols, crisis communications, or personal branding.

Use when choosing or evaluating the concrete building blocks of a visual identity — deciding which type of logo or mark fits a brand (wordmark, letterform, pictorial, abstract, emblem, dynamic), naming a company or product, judging whether a name or tagline is strong, or picking whether a brand needs a character. Reach for it whenever the question is 'what type of mark/name/tagline should this be' rather than how to run the identity process.

Use when someone conflates brand, branding, brand identity, and brand strategy or asks what those words mean; when justifying investment in identity; when mapping stakeholders, aligning culture with brand, defining brand experience, or choosing a brand-architecture type (branded house vs house of brands vs endorsed/hybrid); or when scoping visual identity, messaging/voice, or governance.

Use when judging, critiquing, or defending brand identity work and functional checkboxes (recognizable, protectable, consistent) aren't enough to explain why one identity is better; evaluating a proposed logo/system, setting acceptance criteria for an identity project, repositioning a brand, or grading a merger/retail/venture identity against a rubric.

Use when deciding whether to refresh an existing brand, evolve vs overhaul a brandmark, redesign packaging, or rename a company or product — and when judging how much brand equity to preserve, whether a redesign is warranted, or how to justify the business case for change.

Use when the user invokes /brand, or asks to build, name, position, design, roll out, evaluate, or refresh a brand identity — a logo/brandmark, brand strategy, positioning, brand brief, visual system, brand guidelines, touchpoints, or a rebrand — and it is unclear which brand-identity reference skills apply. Dispatcher that routes to the right companion skills distilled from Wheeler & Meyerson's Designing Brand Identity (6e).

Use when defining what a brand stands for and what to call it — distilling research into a unifying idea, narrowing focus, writing a positioning strategy, developing a brand brief, running a naming project, or screening names for trademark/legal availability. Also when a merger, joint venture, blank-page startup, or repositioning needs a strategy or name.