Skip to content

Recently active skills

Trending is calculated from star growth this site has recorded itself. No history is estimated or back-filled.

Not enough history yet: 2 of 7 days recorded. Until then this list is ordered by the most recent content change.

30563 skills

ideationjacob-balslev/skillsUse when generating a wide range of solution concepts before converging on a direction, running structured idea-generation sessions, breaking out of solution fixation, or moving from divergent to convergent selection with explicit criteria. Do NOT use for collaborative engineering domain discovery (event-storming), solo deep technical design, or making final go/no-go investment decisions — those require different methods.Stars: 2Updated Claude CodeCodexUnverifiedInstall
information-architecturejacob-balslev/skillsUse when structuring information for findability: navigation, page hierarchy, docs architecture, sitemap shape, labeling systems, wayfinding, and content grouping. Do NOT use for formal category-governance work (use `taxonomy-design`), responsive page composition (use `layout-composition`), component/token architecture (use `design-system-architecture`), or sentence-level UI text (use `microcopy`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
interaction-feedbackjacob-balslev/skillsUse when designing UI feedback around user actions and system state: loading, skeletons, optimistic updates, progress, success, errors, empty states, retries, disabled/pending states, autosave, undo, and perceived latency. Do NOT use for the words inside feedback (use `microcopy`), accessibility announcement mechanics (use `a11y`), business lifecycle modeling (use `state-machine-modeling`), or performance optimization (use `performance-engineering`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
interaction-patternsjacob-balslev/skillsUse when choosing or auditing UI interaction patterns and controls: tabs vs pages, dropdown vs combobox, stepper vs wizard, modal vs inline edit, disclosure, command menus, selection, filtering, and gesture alternatives. Do NOT use for accessibility compliance (use `a11y`), task decomposition (use `task-analysis`), feedback-state staging (use `interaction-feedback`), or reusable component API design (use `design-system-architecture`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
journey-mappingjacob-balslev/skillsUse when mapping a user's experience across multiple touchpoints and time, surfacing emotional peaks and troughs, identifying opportunity moments in a cross-channel flow, or aligning a team on the end-to-end experience including back-stage support processes. Do NOT use for decomposing a single screen into UI steps (use task-analysis) or for drawing back-end service architecture diagrams — journey maps describe human experience, not system topology.Stars: 2Updated Claude CodeCodexUnverifiedInstall
layout-compositionjacob-balslev/skillsUse when deciding responsive page or screen structure: section order, scan pattern, grid/flex composition, breakpoints, viewport hierarchy, responsive media, and density. Do NOT use for user-goal decomposition (use `task-analysis`), navigation taxonomy (use `information-architecture`), visual polish (use `visual-design-foundations`), or component/token contracts (use `design-system-architecture`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
microcopyjacob-balslev/skillsUse when writing or reviewing functional UI text: button labels, empty states, tooltips, dialogs, placeholders, loading/progress messages, toasts, inline validation, permission copy, or onboarding steps. Covers interface-copy patterns such as verb-first action labels, acknowledge-explain-guide empty states, one-sentence tooltips, consequence-first confirmations, progressive loading language, and blur/fix validation messages. Do NOT use for marketing persuasion, documentation prose/guide structure, feedback-state staging, or general linguistic rationale behind wording.Stars: 2Updated Claude CodeCodexUnverifiedInstall
prototypingjacob-balslev/skillsUse when building an artifact whose purpose is to answer a specific question — paper sketch, wireframe, clickable mockup, wizard-of-oz, role-play, service prototype, or code spike — at the lowest fidelity sufficient to produce that learning. Do NOT use for production-grade component construction, design-system contribution, or building the actual ship-ready feature — those are design-module-composition and engineering implementation.Stars: 2Updated Claude CodeCodexUnverifiedInstall
research-synthesisjacob-balslev/skillsUse when turning raw qualitative research output (interview transcripts, field notes, diary entries, observation logs) into themes, patterns, insight statements, and design-ready artifacts via affinity mapping, empathy maps, and jobs-to-be-done framing. Do NOT use for collecting new research, quantitative analysis, statistical inference, or summarizing a single document — synthesis specifically operates on a corpus of qualitative evidence.Stars: 2Updated Claude CodeCodexUnverifiedInstall
semioticsjacob-balslev/skillsUse when designing or auditing icon systems, colors/badges/shapes, visual metaphors, interface signs, or naming-plus-visual surfaces that users misread. Covers semiotic reasoning across icon/index/symbol, signifier/signified, denotation/connotation/myth, color/shape/position/iconography, affordances, code/API signifiers, and semiotic-coherence audits. Do NOT use for actual UI wording (use `microcopy`), palette/typography craft (use `visual-design-foundations`), accessibility or contrast compliance (use `a11y`), formal class hierarchies, or word morphology rules.Stars: 2Updated Claude CodeCodexUnverifiedInstall
typography-systemjacob-balslev/skillsUse when designing a typography system — typeface selection and pairing, modular type scale, vertical rhythm, line-height and measure rules, and web font delivery (subsetting, font-display, variable fonts). Do NOT use for body copy writing, single-headline font pairing, or non-text design tokens.Stars: 2Updated Claude CodeCodexUnverifiedInstall
usability-testingjacob-balslev/skillsUse when observing representative real users attempting realistic tasks on a prototype or live product to surface usability issues: moderated or unmoderated, remote or in-person, concurrent or retrospective think-aloud, task scenarios, participant screening, tree/first-click testing for IA findability questions, pilot runs, severity rating, sample sizing by claim type, and ethical recording/consent. Do NOT use for automated test suites, code coverage, CI pipelines, unit/integration testing, load testing, or replacing participants with AI/synthetic users; those are engineering verification or synthetic-analysis concerns, not human-behavior observation.Stars: 2Updated Claude CodeCodexUnverifiedInstall
user-researchjacob-balslev/skillsUse when planning or conducting generative qualitative research with real users — interviews, contextual inquiry, ethnographic observation, diary studies — to learn what people do, think, and need in their own context. Do NOT use for analytics review, survey statistics, A/B test interpretation, or agent-side intent classification — those are different research practices entirely.Stars: 2Updated Claude CodeCodexUnverifiedInstall
visual-design-foundationsjacob-balslev/skillsUse when designing or auditing visual craft at foundation level: color palette, typography, spacing, elevation, rhythm, density, optical alignment, visual hierarchy direction, brand fit, contrast intent, and motion feel — making a surface more legible, polished, scannable, and tone-appropriate without changing its task structure. Do NOT use for sign-system meaning (use `semiotics`), token/component architecture (use `design-system-architecture`), responsive structure (use `layout-composition`), accessibility compliance (use `a11y`), or the DEEP contract of one dimension — formal color systems (use `color-system-design`), full type systems (use `typography-system`), deep hierarchy modeling (use `visual-hierarchy`), theming/token delivery (use `theme-system-design`), or interaction-state feedback (use `interaction-feedback`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
visual-hierarchyjacob-balslev/skillsUse when establishing visual hierarchy — type scale ratios, spacing rhythm, contrast as ordering signal, weight and size as importance, and the layered relationship between primary, secondary, and tertiary information. Do NOT use for content writing, information architecture, or specific color palette construction.Stars: 2Updated Claude CodeCodexUnverifiedInstall
writing-humanizerjacob-balslev/skillsUse when writing or editing human-readable prose such as docs, PRs, issues, release notes, errors, UI copy, commits, tooltips, or support replies, especially when text sounds robotic, padded, monotonous, or overly formal. Covers AI-tell removal, active voice, hedging reduction, readability diagnosis, sentence rhythm, vocabulary variety, tone mapping, paragraph rhythm, bullets-vs-prose choice, and the 5-step humanization workflow. Do NOT use for documentation routing/type selection, code-identifier naming, or in-product UI-text pattern catalogs.Stars: 2Updated Claude CodeCodexUnverifiedInstall
client-server-boundaryjacob-balslev/skillsUse when reasoning about the line where execution context changes between server runtime and client runtime: what values can cross via the active serializer, what cannot, how `'use client'`, `'use server'`, guard imports, and server-only file conventions mark module/function transitions, how React Server Components differ from server-rendered HTML, why Server Functions / Server Actions are reachable network endpoints, why client input is adversarial, and how server-only modules, secrets, raw records, or closures leak into client bundles and payloads. Do NOT use for choosing when and where UI is produced (use rendering-models), full Server Component read-path placement (use server-components-design), full Server Action mutation/form/cache design (use server-actions-design), public Route Handler endpoint design (use route-handler-design), HTTP wire semantics (use http-semantics), frontend codebase organization (use frontend-architecture), or API JSON contract design (use api-design).Stars: 2Updated Claude CodeCodexUnverifiedInstall
design-system-architecturejacob-balslev/skillsUse when designing or auditing a design system's architecture: token taxonomy, semantic tokens, component APIs, theming, accessibility contracts, documentation, governance, and migration strategy. Do NOT use for information hierarchy and navigation (use `information-architecture`), page-specific layout (use `layout-composition`), visual craft direction (use `visual-design-foundations`), sentence-level UI copy (use `microcopy`), or accessibility-only audits (use `a11y`).Stars: 2Updated Claude CodeCodexUnverifiedInstall
error-boundaryjacob-balslev/skillsUse when designing or reviewing React error boundaries: what an error boundary catches (rendering errors, lifecycle errors, constructor errors) and what it does not (event handler errors, async errors, SSR errors, errors in the boundary itself), why React still requires class components for error boundaries, how to place boundaries by granularity (page / feature / leaf), how error boundaries pair with Suspense, the reset-and-recover pattern (resetKeys, error.reset), the Next.js error.tsx route-segment convention, and how to integrate boundaries with error reporting (Sentry, observability). Covers React 18+ and Next.js App Router. Do NOT use for Suspense boundary placement (use suspense-patterns), for general error-handling discipline (try/catch in async code, validation errors), for backend error contracts (use api-design), or for observability infrastructure (use error-tracking).Stars: 2Updated Claude CodeCodexUnverifiedInstall
frontend-architecturejacob-balslev/skillsUse when organizing a frontend codebase: module boundaries, component layering, state ownership, data-flow direction, route/file colocation, public module APIs, and the separation between feature code and shared primitives. Do NOT use for visual design decisions, detailed React Server Component/read-path design, rendering-model selection, specific framework migration tactics, or backend API contract design.Stars: 2Updated Claude CodeCodexUnverifiedInstall
generative-uijacob-balslev/skillsUse when reasoning about the pattern where a language model emits, as structured output, a description of UI components or a UI sub-tree that an application then renders for the user: the typed-schema component palette, the structured-output mechanism (JSON Schema, function-calling) that constrains emission to renderable specs, the two render substrates (typed-component-tree vs sandboxed-iframe), the application-side render pipeline that turns the spec into pixels, the bidirectional interaction loop (postMessage/JSON-RPC) by which user actions on the rendered UI flow back into the next turn, the security boundary between model-author and application-renderer, and the difference between this and adjacent patterns (chat with markdown, prebuilt-widget routing, RSC streaming, model-emits-code). Do NOT use for the page-level rendering taxonomy (use rendering-models), the protocol cycle of tool calls (use tool-call-flow), the trust boundary against untrusted content (use prompt-injection-defense), or general component-library architecture (use design-system-architecture).Stars: 2Updated Claude CodeCodexUnverifiedInstall
hooks-patternsjacob-balslev/skillsUse when reasoning about React Hooks as a discipline: why the Rules of Hooks exist as a call-order invariant, how dependency arrays encode a contract between closure and rerender, when useEffect is the wrong primitive, the distinction between derived state and stored state, when to extract a custom hook, when memoization (useMemo, useCallback, memo) is useful or obsolete, and how React 18/19 semantics (automatic batching, concurrent rendering, Strict Mode effect checks, Effect Events, React Compiler) change the calculus. Do NOT use for general React rendering models (use rendering-models), the client/server boundary (use client-server-boundary), component API architecture (use component-architecture), Suspense boundary design (use suspense-patterns), or application-wide state location (use state-management).Stars: 2Updated Claude CodeCodexUnverifiedInstall
middleware-patternsjacob-balslev/skillsUse when designing or reviewing the Next.js request-preprocessing layer — the single root file that runs cross-cutting request/response transforms before route resolution. As of Next.js 16 this file is `proxy.ts` (function `proxy`, Node.js runtime, default export or named); `middleware.ts` (function `middleware`, Edge Runtime by default — Node.js opt-in since 15.5) is deprecated but retained for Edge use cases. Covers: the runtime split (proxy = Node.js, runtime config throws; middleware.ts = Edge by default with its capability ceiling, Node.js opt-in since 15.5), the `matcher` config that decides which paths it runs on, the `NextRequest`/`NextResponse` API for cookies/headers (and `geolocation()`/`ipAddress()` from `@vercel/functions` since `request.geo`/`request.ip` were removed in Next.js 15), the four response shapes (`next`/`rewrite`/`redirect`/direct response), `waitUntil` for background work, the official `next/experimental/testing/server` test utilities, the canonical patterns (auth gate, locale routing, A/B testing, header injection, geo-routing, bot blocking), the per-matched-request performance discipline, the CVE-2025-29927 lesson that this layer is NOT a security boundary, and the design rule that it is for cross-cutting concerns across many routes — never per-route business logic. Do NOT use for per-route HTTP endpoint logic (use route-handler-design), the Server Action mutation surface (use server-actions-design), abstract HTTP method/status/header semantics (use http-semantics), Content Security Policy and broader hardening (use security-fundamentals), or the cross-cutting streaming model (use streaming-architecture).Stars: 2Updated Claude CodeCodexUnverifiedInstall
mobile-responsive-uxjacob-balslev/skillsUse when designing mobile-specific UX for dashboards and operational web apps: touch-friendly targets, thumb-zone optimization, swipe gestures, condensed data display, bottom navigation, bottom sheets, mobile inputs, and pull-to-refresh. Load when adapting a desktop dashboard to phone use, implementing touch interactions, or checking whether a mobile layout serves quick-glance tasks rather than compressed desktop analysis. Do NOT use for general responsive layout structure across all breakpoints (layout-composition), accessibility compliance breadth such as ARIA, keyboard, and screen reader audits (a11y), or component/token architecture (design-system-architecture).Stars: 2Updated Claude CodeCodexUnverifiedInstall
ref-patternsjacob-balslev/skillsUse when designing or reviewing React ref usage: the distinction between refs (mutable handle that survives renders without triggering them) and state (reactive value that triggers renders when changed), the `useRef` hook for DOM access and mutable instance values, ref callbacks for fine-grained mount/unmount hooks, `forwardRef` for passing refs through component boundaries (and the React 19 ref-as-prop change that retires it for new code), `useImperativeHandle` for exposing a controlled imperative surface to parent refs, ref forwarding through compound-component primitives (the Radix `Slot` / Headless UI pattern), and the design rule that refs are an escape hatch — for DOM access, integration with non-React DOM libraries, focus management, animation, measurement, and exposing imperative APIs sparingly, never as a substitute for state. Do NOT use for the broader hook discipline — Rules of Hooks, dependency arrays, custom hooks (use hooks-patterns), for the cross-product component-layering question — primitives/composites/headless-vs-styled (use component-architecture), for state location and ownership decisions (use state-management), for the `'use client'` / `'use server'` boundary mechanics (use client-server-boundary), or for form-state and validation patterns (use form-ux-architecture).Stars: 2Updated Claude CodeCodexUnverifiedInstall
rendering-modelsjacob-balslev/skillsUse when reasoning about how a web UI is produced and delivered: client-side rendering, server-side rendering, static-site generation, incremental static regeneration, React Server Components, streaming SSR, edge rendering, and partial prerendering. Covers the time × place grid (build/request/stream/interaction × server/edge/client), the trade-offs between first-paint latency and time-to-interactive, the relationship between rendering and hydration, and how a route's content profile (dynamic / static / personalized) maps to a model. Do NOT use for organizing the frontend codebase (use frontend-architecture), the serialization frontier between server and client code (use client-server-boundary), the wire protocol itself (use http-semantics), or specific deploy-platform composition patterns (use vercel-composition-patterns).Stars: 2Updated Claude CodeCodexUnverifiedInstall
server-actions-designjacob-balslev/skillsUse when designing or reviewing React Server Functions / Next.js Server Actions for mutations: the 'use server' directive, function-to-POST endpoint semantics, form integration through action/formAction, React useActionState and useFormStatus, progressive enhancement, server-side validation, authentication, authorization, rate limiting, cache revalidation, redirect/refresh/updateTag behavior, bound arguments, and the security boundary that makes actions public HTTP endpoints despite function-like syntax. Covers Next.js App Router as the canonical implementation. Do NOT use for read-path data fetching with React Server Components (use server-components-design), broader serialization/directive mechanics (use client-server-boundary), externally consumed API contracts (use api-design), or form visual/interaction UX (use form-ux-architecture).Stars: 2Updated Claude CodeCodexUnverifiedInstall
server-components-designjacob-balslev/skillsUse when designing or reviewing React Server Components: what an RSC can do (async, data fetching, server-only imports) versus what it cannot (state, effects, event handlers, browser APIs), where to draw the server/client boundary in the tree, how to keep private data from leaking across that boundary, and how RSC composes with Suspense to stream content without a separate API layer. Covers Next.js App Router as the canonical implementation, but the discipline is framework-agnostic. Do NOT use for the 'use client' directive mechanics (use client-server-boundary), hook discipline on Client Components (use hooks-patterns), rendering strategy choice (use rendering-models), the server-action mutation surface (use server-actions-design), or the wider Suspense discipline (use suspense-patterns).Stars: 2Updated Claude CodeCodexUnverifiedInstall
state-managementjacob-balslev/skillsUse when deciding where state lives, how it propagates, and how it composes: local component state vs lifted/shared state vs application state, server state vs client state, URL as state, persistent state, derived state, and the cross-cutting decision of who owns which piece. Covers state colocation, lifting up, derivation vs duplication, single source of truth, optimistic updates, server-state cache invalidation (React Query/SWR model), URL state for deep-linking, and anti-patterns like prop-drilling, state sprawl, and global-state-by-default. Do NOT use for specific state library choice (Redux vs Zustand — tactical), data fetching mechanics (use api-design or rendering-models), client/server boundary (use client-server-boundary), distributed system state (use replication-patterns), or finite state machines (use state-machine-modeling).Stars: 2Updated Claude CodeCodexUnverifiedInstall
suspense-patternsjacob-balslev/skillsUse when designing or reviewing React Suspense usage: where to place Suspense boundaries to control loading granularity, the difference between Suspense for data fetching and Suspense for code splitting, how Suspense interacts with Server Components for streaming HTML, how error boundaries pair with Suspense (and why they must be distinct components), the relationship between Suspense and React's transition APIs (useTransition, startTransition), and the design rules that prevent waterfall fetches, layout shift, and SEO regressions. Covers React 18+ and 19's `use` hook for unwrapping Promises in Client Components. Do NOT use for general React rendering strategy choice (use rendering-models), for the underlying hook primitives (use hooks-patterns), for streaming protocols beyond Suspense (use streaming-architecture), or for Server Component design (use server-components-design).Stars: 2Updated Claude CodeCodexUnverifiedInstall