aryaniyaps
UserHeadless Product Design skill for AI coding agents | Design how it works, verify what you ship.
Categories
Indexed Skills (50)
lamina
Product design skill for developers who build with AI coding agents. Use when you need to know what to build before prompting your agent — domain model, workflows, edge cases, product states, and UX gaps handled upfront. Works alongside Cursor, Claude Code, Codex, Gemini, Pi. Any stack, any UI library. Do NOT use for visual styling, pixel layouts, or writing app source.
lamina-business-context
Business context UX guidance. Use when bootstrapping Lamina for a project; answering business questions UX work needs; updating context after a pivot or scope change.
lamina-consistency-guarantees
Product-facing consistency — what users and actors may see when, stale vs fresh data, and acceptable lag. Use when multiple views must agree without prescribing storage technology.
lamina-decision-making
Prioritize contract gaps and verify findings — impact × effort, primary actor filter. Use when reconciling conflicts or ranking findings[].
lamina-feedback-loops
Feedback loops in product behavior — balancing and reinforcing dynamics, delays, and oscillation. Use when state changes feed back into further change.
lamina-forms
Form behavior in contracts — validation timing, field semantics, and recovery UX. Use when data entry blocks workflows or causes scenario gaps.
lamina-invariants
Product invariants — rules that must always hold, impossible states prevented, errors defined out of existence. Use when defining what can never happen in the product.
lamina-modularity-boundaries
Domain and feature boundaries — hide complexity behind clear ownership, pull complexity away from users. Use when splitting entities, actors, and responsibilities.
lamina-multi-view-integrity
Consistency across actor views — student, admin, and system surfaces must reflect the same domain truth. Use in multi-actor products when roles see different slices of one system.
lamina-product-behavior
Represented model matches domain — UI must not imply illegal states or permissions. Use when the active GraphVersion domain and screens diverge from implementation shape.
lamina-side-effects
Downstream effects of state changes — notifications, updates to related entities, and cross-actor handoffs. Use when one operation must trigger updates beyond the primary screen.
lamina-competitive-analysis
Reference patterns — learn from user-cited competitors or products as evidence. Not market parity slide decks.
lamina-content-design
Copy and labels in contracts — scan-first labels, error text, and empty-state messaging. Use when screen copy blocks actor walks.
lamina-controls-and-menus
Actions and reversibility in contracts — primary/destructive actions, undo policy, confirmations. Use when destructive ops lack scenarios.
lamina-design-process
Agent-native design loop — domain contract, external build, verify, iterate. Not human workshop ceremony.
lamina-discoverability
Signifiers and affordances in screen contracts — actors must see what they can do. Use when actor walks report execution/evaluation gulfs.
lamina-empty-states
Empty and zero-data UX in scenarios — first productive action when domain collections are empty. Use when collection_empty scenarios are missing.
lamina-error-handling
Error and recovery UX in scenarios — slips vs mistakes, root cause in design not actors. Use when mapping failure scenarios in the active GraphVersion.
lamina-evolutionary-rules
Evolving product rules safely — reversible decisions, invariant checks as features change, deferring commitment. Use when the domain will grow or requirements are uncertain.
lamina-feature-discovery
Capability discovery — map requests to domain operations, workflows, and actors. Not generative research methods for human labs.
lamina-feature-prioritization
Scope prioritization — rank workflows by invariant risk and actor impact. Not roadmap theater or featuritis dogma.
lamina-feedback-and-status
System state visibility in contracts — modeless feedback, progress, and async status. Use when actors can't tell what happened after actions.
lamina-field-research
Live product grounding — repo and browser observation of real behavior. Not ethnography logistics.
lamina-heuristic-review
Expert lens review — parallel contract, a11y, and invariant checks. Not Nielsen heuristic checklist theater.
lamina-idempotency-concurrency
Duplicate actions and simultaneous edits — double-submit, concurrent admin updates, and safe retries in product behavior. Use when shared resources can be mutated by multiple actors or requests.
lamina-information-architecture
Entity organization and retrieval — how actors find domain objects in screens and nav. Use when IA mirrors files or tables instead of tasks.
lamina-interview-design
Actor-walk script design — probe operations, goals, and failure modes per simulated actor. Not human moderator craft.
lamina-interview-documentation
Walkthrough evidence — structured capture from browser/repo sessions. Not human session notes.
lamina-leverage-points
High-impact intervention points in product design — rules, information flows, and goals over UI tweaks. Use when local fixes fail to change behavior.
lamina-navigation
Wayfinding in contracts — persistent nav, orientation, and hierarchy per screen. Use when actors get lost in verify walks.
lamina-onboarding
First-run and learnability — primary path without training, progressive power features. Use when new actors can't complete first workflow in verify.
lamina-persuasion-and-groups
Multi-actor dynamics — group permissions, shared resources, and social side-effects. Not persuasion craft or influence tactics.
lamina-platform-posture
Product density — how much complexity the domain tolerates on each surface. Not sovereign/transient platform essays.
lamina-problem-framing
Design intake — align user request to domain scope, actors, and success outcome. Not pre-fieldwork research questions.
lamina-progressive-disclosure
Progressive disclosure in contracts — essential vs advanced actions per actor. Use when novices overwhelmed or experts blocked on power features.
lamina-quantitative-validation
Metrics discipline — use only real user-provided data; suggest what to measure post-launch. No invented A/B results.
lamina-research-communication
Findings communication — structured verify report for humans and coding agents. Not executive highlight reels.
lamina-research-planning
Simulation planning — plan actor walks, invariant probes, and walkthrough capture for verify. Not recruitment logistics.
lamina-research-scoping
Evidence scoping — what grounding is needed (repo, walkthrough, user input) vs assumption. Not human study scope.
lamina-research-synthesis
Simulation synthesis — merge parallel actor-walk and walkthrough results into findings[]. Not affinity mapping human interviews.
lamina-stakeholder-alignment
Multi-actor goal alignment — explicit trade-offs and permission conflicts in contract. Not org politics or workshop facilitation.
lamina-core
Lamina Problem Router — product design at the intersection of UX, product rules, and systems thinking.
lamina-design
Use only when explicitly invoked as lamina-design. Shape intended product behavior in Lamina's transactional graph and publish a validated graph version.
lamina-init
Use only when explicitly invoked as lamina-init. Establish business evidence and canonical Product, Actor, and Persona resources in Lamina's transactional graph.
lamina-accessibility
Specify and verify accessibility behavior on product-graph surfaces and workflows, including semantics, keyboard reachability, focus, errors, async status, and non-visual state communication.
lamina-dependencies
Map prerequisite, data, lifecycle, and reachability dependencies between typed product-graph nodes, including explicit behavior when a dependency is unmet.
lamina-edge-cases
Derive distinct product-risk scenarios from operations, dependencies, authority, lifecycles, concurrency, destructive actions, and recovery without generating exhaustive or duplicate edge-case lists.
lamina-flow-design
Design reachable actor workflows from typed product operations, dependencies, and terminal outcomes, including complete cross-actor handoffs and recovery.
lamina-orchestrator
Transactional product-graph workflows for design, source observation, Persona Missions, and runtime verification.
lamina-requirements-definition
Translate product intent into traceable critical promises, graph nodes, observable scenarios, assumptions, and scope without prescribing unnecessary implementation details.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.