aryaniyaps
UserHeadless product design for AI coding agents, backed by a transactional product graph | Design how it works, verify what you ship.
Categories
Indexed Skills (56)
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-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-design-process
Agent-native design loop — domain contract, external build, verify, iterate. Not human workshop ceremony.
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-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
Route ordinary product implementation and explicit Lamina lifecycle requests. Use passively after initialization for changes to product behavior, flows, permissions, states, failures, or UI; skip purely mechanical maintenance.
lamina-core
Lamina Problem Router — product design at the intersection of UX, product rules, and systems thinking.
lamina-product-behavior
Define authoritative runtime product truth across actors and views. Use when modeling domain behavior, setting product density, specifying side effects, protecting invariants, choosing consistency guarantees, handling retries or concurrent actions, defining time semantics and prerequisites, drawing ownership boundaries, or keeping views coherent. Use lamina-systems for causal loops and change over time, and lamina-ux for interaction expression.
lamina-design
Shape intended product behavior in Lamina's transactional graph when explicitly invoked as lamina-design or when passive implementation preparation reports design gaps. Publish an implementation-ready graph version without editing application source.
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-product-discovery
Frame product problems and decide what to build. Use when establishing business context, aligning actors with conflicting goals, discovering or prioritizing features, defining traceable requirements, comparing consequential tradeoffs, or recording a product decision. Use lamina-ux for interaction details and lamina-product-behavior for authoritative runtime rules.
lamina-research
Plan and synthesize evidence-grounded product research. Use when deciding what evidence is needed, designing actor walkthroughs, grounding claims in a repository or live product, analyzing user-provided references, modeling users and tasks, or communicating findings without inventing data. Use lamina-evaluation instead to judge a built product, and lamina-ux to design interaction behavior.
lamina-ux
Design understandable and accessible product interactions. Use when shaping workflows, information architecture, navigation, interface copy, forms, controls, empty states, onboarding, feedback, error recovery, progressive disclosure, discoverability, accessibility, trust, group dynamics, or interaction edge cases. Use lamina-product-behavior for authoritative state rules and lamina-evaluation to judge a built product.
lamina-verify
Verify graph-backed product Missions after ordinary implementation work or when explicitly invoked as lamina-verify. Run isolated Persona and live UI audits; explicit verification is source-read-only.
lamina-orchestrator
Transactional product-graph workflows for design, source observation, Persona Missions, and runtime verification.
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-requirements-definition
Translate product intent into traceable critical promises, graph nodes, observable scenarios, assumptions, and scope without prescribing unnecessary implementation details.
lamina-evaluation
Judge product usability and evidence quality. Use when running Persona-based walkthroughs on a built product, planning an expert heuristic review, defining evidence-backed success metrics, or checking quantitative claims without inventing measurements. Use lamina-research to plan or synthesize evidence collection and lamina-ux to design interaction behavior.
lamina-systems
Reason about causal product systems and change over time. Use when mapping stocks, flows, delays, purposes, or interconnections; diagnosing reinforcing or balancing feedback; recognizing recurring traps; finding high-leverage interventions; or deciding how rules can evolve safely. Use lamina-product-behavior for one workflow's authoritative states, prerequisites, and consistency rules.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.