Folderloom
Organize and reuse ChatGPT, Claude, and Gemini chats with folders and a prompt library.
Practical resources for thoughtful AI products. Find what helps, then make it yours.
Organize and reuse ChatGPT, Claude, and Gemini chats with folders and a prompt library.
Transcribe and translate video content to follow useful videos across languages.
Prepare a one-to-one conversation with clear topics and follow-ups.
Find component and template references when evaluating interface implementation options.
Turn an interface into specific, actionable feedback before you change it.
Make an experiment decision using predefined metrics and uncertainty.
Define an experiment's hypothesis and the evidence needed to evaluate it.
Identify the inputs needed to estimate a useful experiment size and duration.
Design an experiment with a falsifiable hypothesis, assignment unit, guardrails, and stopping rules.
Make a feature's completion conditions concrete enough to test.
Create a repeatable checklist for reviewing interface accessibility.
Report accessibility issues with enough context for remediation and verification.
Test inclusive task completion across keyboard, assistive technology, and responsive layouts.
Develop ad concepts from substantiated benefits and a defined audience situation.
Choose a visual direction that reflects the audience and purpose of a screen.
Organize qualitative observations into themes while keeping evidence traceable.
Automate browser work only through permitted tooling and observed controls.
Collect precise visual feedback with target elements and task context before editing UI.
Compose an AI conversation from clear message, tool, input, and output boundaries.
Give people useful recovery options when an AI result fails or is uncertain.
Build an evaluation set from real failure modes and explicit quality criteria; separate development from held-out cases.
Describe an AI feature's intended behavior and the controls people need.
Brief image generation around subject, composition, material, light, and intended use.
Develop logo ideas from a strategic brief before creating final assets.
Compare model choices against the demands of a specific task.
Use AI to explore and prototype while retaining responsibility for evidence, evaluation, and design decisions.
Design an AI feature with validated structured output, explicit failure states, and an evaluation set.
Choose AI investment from customer need, model limits, cost, and control requirements.
Check an AI-generated interface against the system it should follow.
Improve content discoverability by making claims, entities, evidence, and source dates explicit.
Refine instructions for an AI design tool around the output you need.
Brief video generation around subject, action, camera, temporal continuity, and permitted references.
Express a visual idea through explicit parameters and reproducible generative rules.
Test a product idea by writing the customer-facing announcement and likely questions.
Turn product analytics observations into design questions and next steps.
Define privacy-aware analytics from business questions, consent, event meaning, and data minimization.
Turn a process into a readable mechanical diagram: identify inputs, transformations, and outputs before choosing geometry.
Apply Android interaction and layout guidance to the specific device and task.
Choose whether motion is useful before specifying properties, easing, and duration.
Find the cause of dropped animation frames before changing timing; examine layout work and expensive effects.
Translate a vague motion brief into concrete movement, timing, and interaction terms.
Draft procurement answers from security practices you can actually substantiate.
Prepare app-store visuals from verified product behavior and current platform specifications.
Adapt fluid-interface principles to the actual platform without imitating chrome unnecessarily.
Design iOS tasks using current platform guidance and system-appropriate components.
Make an iOS interface feel native through appropriate controls and content hierarchy.
Ground audience profiles in observed needs and buying context.
Check whether your Claude Code instructions produce better results on a repeatable task.
Locate friction across a marketing funnel and rank the next experiments.
Prepare evidence-based examples for questions about how you work.
Describe behavior patterns supported by research rather than invented demographics.
Collect focused feedback from people trying an unreleased product.
Engineer accessible controls through native semantics and correct focus/state handling.
Create semantic color roles with measured contrast and explicit light/dark mapping.
Review a Figma screen for hierarchy, layout, interaction states, and wording with element-level evidence.
Choose grouping and layout from reading order, information priority, and responsive constraints.
Tune typography through content hierarchy, font metrics, wrapping, and script support.
Refine interface details through consistent surfaces, optical alignment, and restrained feedback.
Keep a record of contributions and evidence of their impact.
Explore the user's intended outcome and existing context before committing to a solution.
Use brand archetypes to explore a coherent voice and storytelling direction.
Translate a campaign objective into creative directions and evaluation criteria.
Build a usable brand palette with roles and contrast considerations.
Check visual and verbal materials against a shared set of brand rules.
Apply supplied brand rules accurately and identify missing guidance instead of inventing authority.
Review whether a brand is recognized, understood, and consistently expressed.
Turn brand goals into a brief a visual designer can work from.
Explain the investment, expected value, and uncertainty of a brand initiative.
Coordinate the assets and teams needed to introduce a new identity.
Organize a brand's core message and proof for different audiences.
Explore name candidates and explain the trade-offs in a shortlist.
Connect a brand's origins and beliefs to the change it wants to create.
Learn how people recognize and describe a brand through survey questions.
Articulate who a brand serves and the promise it can credibly make.
Present a brand strategy as a sequence of decisions and supporting evidence.
Describe your brand's visual rules to a prototyping assistant.
Translate brand personality into visual choices for a digital product.
Describe a brand's voice through concrete writing choices and examples.
Create a brand presentation from a verified positioning brief and practical applications.
Stress-test a component with realistic extreme content before declaring the layout finished.
Connect positioning and visual foundations in a practical starter identity.
Define the evidence reviewers should look for when judging an AI response.
Organize social posts into a maintainable publishing schedule.
Plan a series of emails that moves a reader toward a useful next step.
Develop a static visual composition from a clear message and intentional type/image hierarchy.
Choose skills and work experiences that support a career objective.
Investigate churn by segment and lifecycle stage before proposing retention tactics.
Work with an AI coding agent in a terminal or editor while keeping commands and changes reviewable.
Explore design concepts using the provider's design workspace when it supports the intended artifact.
Audit project memory instructions for accuracy, conflicts, and excessive scope.
Set expectations for a trial engagement before either team commits.
Use edge hosting and application services when their operating model matches the system.
Use an AI coding agent for repository tasks with explicit scope and verification.
Write relevant outbound messages from verified recipient context and a credible small request.
Connect color roles and type scales into a foundation that supports both themes.
Evaluate readable color combinations during palette exploration.
Compare competitor experiences to find design opportunities worth investigating.
Write fair product comparisons tied to verified capabilities and a buyer's actual decision.
Compare how competitors present themselves and look for a defensible opening.
Decide which reusable components deserve attention first.
Test whether people understand and value a proposed concept.
Look for recurring motivations and tensions in customer language.
Choose content from audience questions, credible expertise, and realistic production capacity.
Check color pairings during visual design as one part of accessibility review.
Diagnose a conversion problem before proposing a change; pair primary metrics with downstream quality guardrails.
Explore palette candidates before assigning functional interface roles.
Edit marketing text for audience meaning, substantiated claims, specific actions, and consistent terminology.
Structure marketing copy around the reader's problem, evidence, objections, and next action.
Give Claude Code the project context and commands it needs to work responsibly.
Record interface rules so future changes stay consistent with your visual system.
Package a recurring task as instructions an agent can load and follow.
Document repository conventions and boundaries for coding agents.
Document the governing design language from actual product code and evidence.
Plan a difficult workplace conversation with concrete observations and a clear request.
Work on an existing codebase with an AI-assisted editor and reviewable changes.
Map an end-to-end journey from research, touchpoints, and handoffs.
Choose chart encodings from the comparison or question the data must answer.
Identify the first meaningful result a new user should reach.
Narrow a B2B audience to the buyers and situations your product can serve.
Build a demo around the buyer's problem and prepare for difficult questions.
Prepare Vercel deployment from current project configuration and explicit target authorization.
Map the turns, handoffs, and recovery paths a person needs when working with an AI assistant.
Define the tools, permissions, and review points around an agent's task.
Design an interface API by exploring meaningfully different ways callers could express the task.
Explore direct manipulation and responsive motion for an interface inspired by Apple.
Capture a design project's purpose, audience, and practical constraints.
Approach an interview design exercise with a clear problem-solving process.
Check whether a design covers the states engineering will need to build.
Critique a design against user goals and constraints before expressing a preferred solution.
Guide a critique toward actionable feedback and shared understanding.
Review a design using consistent feedback categories and clear next steps.
Connect visual decisions to implementation details such as focus, layout stability, and control states.
Explain behavior and unresolved decisions beyond static design pixels; link authoritative tokens and assets.
Prepare design specifications and decisions for an engineering handoff.
Work through a design management problem with a coaching perspective.
Choose motion from the task: feedback, continuity, or orientation; specify interruption and reduced-motion behavior.
Compare packaging choices and decide where plans or usage boundaries belong.
Prepare the context and questions needed for a productive design review.
Review a design system for gaps and inconsistent usage.
Define a reusable component with the states and guidance teams need.
Specify the anatomy and token usage of a component across its states.
Explain how teams should use and maintain system components.
Plan adoption and support when introducing a design system.
Translate system rules into instructions for generating a consistent prototype.
Translate visual taste into specific typography, spacing, hierarchy, and content decisions.
Find redundant or inconsistent tokens before they spread across components.
Name reusable visual values and define their semantic roles.
Facilitate a workshop around a concrete decision with balanced participation and documented follow-up.
Recompose a desktop task for mobile reading order and touch input.
Explain a system through clear diagram semantics, labels, and an intentional reading path.
Plan repeated observations that reveal how behavior changes over time.
Prepare directory submissions from accurate positioning and a prioritized audience-fit list.
Use parallel work only for independent authorized tasks and gather every result before completion.
Co-author a document by settling purpose and structure before polishing prose.
Create or edit Word documents with stable styles and a render-and-inspect step.
Explore gradient interpolation for a visual brief that benefits from it.
Introduce your company to an investor with a concise, relevant first message.
Design email sequences from user state, consent, useful content, and exit conditions.
Audit an evaluation pipeline for missing error analysis, judge calibration, leakage, and misleading aggregate scores.
Capture workshop outcomes and outstanding actions in a usable recap.
Sketch diagrams with a hand-drawn appearance for collaborative explanation.
Execute an approved plan in dependency order and verify each material result.
Condense a longer document into the decision and context leaders need.
Explain an AI proposal in terms of the decision, cost, and outcome leadership needs to understand.
Walk a candidate through the assumptions and uncertainty behind an equity package.
Find the interface layer and follow how a screen connects to the rest of a repository.
Extract candidate design rules from authorized public evidence while labelling inferred values.
Identify visible design rules in a screenshot for later validation.
Document design foundations and components from Figma using an MCP connection.
Find expressive interface components when a brief justifies a distinctive interaction.
Compare candidate features using explicit prioritization criteria.
Ask for feedback that is specific enough to act on.
Run collaborative workshops in a shared board tied to explicit facilitation goals.
Outline a collaborative FigJam board around a workshop's purpose.
Design and collaborate on interface structure, components, and shared visual rules.
Build Figma layouts from existing authorized components, variables, and auto-layout rules.
Inspect the authorized Figma file and tool capabilities before reading or changing nodes; preserve IDs and component relationships.
Find where motion could clarify continuity or feedback and reject decorative movement.
Find a skill by task fit, maintainer evidence, permissions, and licensing.
Close implementation with verification, reviewable changes, and clearly stated integration options.
Use an authorized crawl to answer a specific research question without bypassing access controls.
Investigate why users leave and choose retention changes worth testing.
Run founder-led sales discovery around real workflow pain and a bounded pilot.
Build a public website through a visual publishing workflow when fast content iteration matters.
Build a frontend direction from the audience, real content, and existing brand constraints; resolve hierarchy before decorative styling.
Prepare fundraising work around company needs, milestones, investor fit, and disclosure boundaries.
Use a sans-serif type family when its metrics and script coverage fit the product.
Use a monospaced companion for code or aligned data where equal-width characters help.
Outline the screens, navigation, and states needed to take a product concept into design.
Sketch a screen's structure in text before moving into a design tool.
Apply expressive typography and layout variance only when supported by the product brief.
Capture meeting notes and organize follow-up when participants and policy allow it.
Challenge unresolved design assumptions one question at a time using available evidence.
Work through unresolved design decisions before committing to a solution.
Use a structured design interview to create decision records and a shared vocabulary.
Explore unresolved decisions in coherent rounds and update the decision map after each answer.
Plan browser QA around real user flows and observed UI state through permitted browser tooling.
Choose a page structure from its actual content and visitor task rather than a fixed template.
Inspect a screen for usability problems using established heuristics.
Develop an expressive visual direction through coherent composition and intentional materials.
Define the outcomes and evaluation criteria for an early hire.
Bring an authorized web interface into a design workflow for inspection or iteration.
Evaluate an icon family for style fit, coverage, and licensing.
Revise machine-written prose to make its meaning specific and natural.
Plan motion-graphic scenes with explicit timing, assets, and export requirements.
Explore code-oriented motion composition for generated video or interface demonstrations.
Access several icon collections when a project needs breadth and explicit source control.
Combine overlapping ideas into a smaller set of testable concepts.
Choose a structured exercise to explore alternatives to a design problem.
Translate a visual reference into maintainable frontend structure with measured layout decisions.
Generate mobile screen concepts as consistent visual explorations, not working applications.
Generate image assets that fit a real webpage's crop, contrast, and content hierarchy.
Review or build a frontend through purpose, hierarchy, accessible states, typography, and responsive behavior.
Audit existing motion and write a prioritized implementation plan without changing product source.
Turn a search opportunity into a focused page and content plan.
Build a deliberately utilitarian interface from a coherent grid and strong hierarchy.
Organize a site's content so people can find what they need.
Use an interface-oriented type family when legibility and available scripts match the task.
Write internal updates around decisions, outcomes, requests, and known uncertainty; adapt detail to the receiving team.
Review copy and layouts for assumptions that break across languages or locales.
Compare a batch of interviews to identify early patterns and unanswered questions.
Prepare interview stories from real situations, decisions, and outcomes.
Design SwiftUI screens with semantic components, clear state, and platform-appropriate navigation.
Develop a simple character-based mark around recognizable silhouette and clear brand association.
Use a coding-oriented monospaced family for code and technical reading.
Give a task ticket the context and completion conditions collaborators need.
Create motion-design compositions and export them for a real usage context.
Extract public information only within authorized access and a bounded research question.
Keep coding changes surgical by checking assumptions, callers, and observable success conditions.
Coordinate launch responsibilities, timing, and fallback actions.
Define the measures that show whether a launch is working.
Design a lead resource with practical standalone value and a clear consent boundary.
Teach coding interviews through problem structure, incremental hints, and explicit complexity trade-offs.
Test how longer translated text affects key controls and layouts.
Make your professional profile easier for relevant collaborators and recruiters to understand.
Rewrite a professional profile around accurate experience and desired work.
Check localized screens for formatting, directionality, and fallback problems.
Explore logo directions before investing in finished artwork.
Evaluate a logo's legibility and fit, then prioritize revisions.
Document logo variations and the conditions for using each one.
Turn a recurring routine into a workflow with triggers, human checkpoints, and stopping conditions.
Trim supported media without unnecessary re-encoding when precise edits are the main task.
Create Lottie animations in a browser-based composition tool.
Use a consistent SVG icon set for familiar interface actions.
Derive a type scale from content hierarchy, script coverage, and actual layout pressure.
A practical review skill for hierarchy, interaction states, and the details that matter.
Refine optical alignment, control targets, typography, borders, and motion with real content.
Give coding agents a dependable reference for applying your existing design system.
Record where personal data travels and how it is retained or removed.
Generate marketing ideas tied to audience need, distribution access, and testable learning.
Use behavioral principles to explain friction ethically without coercive interfaces.
Build a Material 3 system from semantic tokens, component states, and adaptive layout needs.
Use customer evidence to assess whether a product is meeting an urgent need.
Assess product-market-fit evidence by segment using retention, customer behavior, and properly qualified survey findings.
Give a meeting a purpose, discussion order, and expected decisions.
Extract decisions, owners, and follow-ups from unstructured meeting notes.
Improve small pieces of interface text without changing their intent.
Simplify an interface by removing low-value competition while retaining necessary context.
Combine findings from several research methods into a coherent decision brief.
Design native Android screens using existing Compose components and task-driven navigation.
Adapt a web task to mobile input, safe areas, viewport changes, and interrupted sessions.
Prepare a timed session guide with questions, activities, and useful probes.
Implement gesture, layout, or state transitions in JavaScript or React when simpler CSS is insufficient.
Flag pronunciation and cultural concerns in a name shortlist for further review.
Register or manage a domain through a dedicated domain provider.
Explore generated gradient treatments for supporting visual material.
Understand how proposed investment terms affect ownership and decision-making.
Prepare a list of contract issues to discuss with qualified counsel.
Synthesize authorized Notion material into a sourced document while keeping gaps and conflicting versions visible.
Translate an approved specification into ordered implementation tasks with dependencies and checks.
Capture or stream video using configurable scenes and audio sources.
Prepare a constructive conversation about the terms of a design job offer.
Explore colors in OKLCH while keeping semantic roles and actual output gamut in mind.
Write objectives with outcomes that can be checked at a review.
Optimize onboarding around first useful value with minimal necessary setup.
Plan a portfolio presentation around the audience and allotted time.
Map a desired outcome to customer opportunities before listing solutions and experiments.
Improve a prompt by making the task, constraints, and expected response explicit.
Plan an article's argument and section order before writing the draft.
Improve one marketing page from a concrete visitor decision and observed friction.
Plan paid campaigns with explicit audience hypotheses, budgets, attribution limits, and stopping criteria.
Explore interface composition on a design canvas that can support a design-to-code workflow.
Explain participation, recording, and scheduling in language a research participant can follow.
Identify eligible participants with explicit screening and routing criteria.
Read or generate PDFs with attention to text extraction, pagination, and final rendering.
Explore an agent-assisted design canvas for interface work.
Reflect on results and growth with examples a reviewer can assess.
Explore likely reactions from a defined persona as hypotheses for real testing.
Choose an icon family with consistent visual weight and enough task coverage.
Choose a UI dependency only after inspecting installed alternatives and the actual capability gap.
Build a pitch narrative linking customer pain, product proof, distribution, economics, and the financing decision.
Explain specialist terminology in language a broader audience can understand.
Schedule campaign deliverables around their dependencies and intended audiences.
Choose useful topics and channels based on the audience you want to serve.
Choose audiences, channels, and a sequence for taking a product to market.
Coordinate launch messages so each audience gets relevant information.
Plan social posts around a channel's audience and publishing goals.
Hand off product intent with bounded scope, rules, dependencies, and unresolved decisions.
Review a frontend screen and choose the changes that most improve its clarity and finish.
Review transitions and interaction feedback without overwhelming the task.
Write portfolio pages that explain your experience and invite the right contact.
Explain a product's differences using customer-relevant evidence.
Review a released feature against its goals and real user feedback.
Plan slide hierarchy and reading order before choosing visuals; use one argument per slide and label evidence.
Create presentation files with a coherent narrative, readable layout, and verified rendering.
Prepare clear answers and supporting material for an investor's review.
Compare competitor plans in terms of price, limits, and customer value.
Compare pricing models against customer value, usage distribution, and cost uncertainty.
State a user problem in a way a team can investigate and prioritize.
Plan launch readiness, distribution, communication, and learning as connected workstreams.
Track the cross-team work that must be finished before release.
Create naming conventions that keep a growing product family understandable.
Connect discovery, prioritization, requirements, and delivery through explicit product decisions.
Document positioning, audience, proof, and customer language as maintained context.
Describe the problem, requirements, and success criteria for a product initiative.
Organize future work around goals, dependencies, and delivery constraints.
Create scaled pages only when each record supplies distinct useful information.
Agree on deliverables, boundaries, and assumptions before a project grows.
Structure a project recap around outcomes, evidence, and lessons.
Write a few durable principles for making project trade-offs.
Connect evidence of your work to expectations for the next level.
Understand the basic choices that make instructions to an AI more useful.
Describe an image through subject, composition, light, material, and intended crop.
Describe video through temporal action, continuity, camera, and scene transitions.
Prototype the riskiest interaction with realistic states and minimal infrastructure.
Turn quarterly metrics into a discussion of progress and priorities.
Assess how clearly your public content explains entities and supports citations by AI search.
Explore animated React components for a specific interface need.
Define what a rebrand should change and what it needs to preserve.
Evaluate review feedback against code, requirements, and a reproducible failure.
Find relevant public discussions and draft helpful disclosed replies while respecting community rules.
Refine an existing interface by tracing the user task and preserving working behavior.
Design a referral program around genuine fit, understandable incentives, and abuse boundaries.
Explain a release through changes users can recognize and act on.
Generate video programmatically from React scenes and deterministic inputs.
Build a Remotion composition using explicit frame timing, deterministic inputs, and reusable scene boundaries.
Prepare authorized Remotion rendering with validated inputs and explicit output settings.
Review a change in its surrounding flow, prioritize concrete defects, and explain user impact.
Investigate a bounded question through authoritative sources with dated claims and explicit uncertainty.
Turn a research theme into an implication and a recommended action.
Narrow a broad stakeholder request into questions a study can resolve.
Build a research presentation around findings, evidence, and decisions.
Rank research requests against their value, urgency, and available capacity.
Plan how content and controls should adapt to different screen sizes.
Improve resume clarity and role relevance using verified experience rather than fabricated ATS scores.
Review animation code for continuity, input responsiveness, interruption, and reduced motion.
Use bounded independent review to check work against explicit acceptance criteria.
Plan a sales conversation that uncovers the prospect's current process and needs.
Explore a geometric sans-serif for a visual direction that needs its character.
Add structured data only for information visibly supported by the page and relevant schema definitions.
Cut scope by protecting the smallest useful end-to-end outcome; map dependencies and explicit deferrals.
Walk through tasks using a screen reader and record obstacles.
Record polished product walkthroughs when the interface needs to be demonstrated.
Plan a scroll-led page around one meaningful narrative moment and mobile composition.
Connect conventional search intent with citation-ready evidence and crawlable information architecture.
Audit crawlability, canonical intent, internal links, and page usefulness with current evidence.
Capture evidence and follow-up questions immediately after a research session.
Link a company-level measure to concrete goals for the next quarter.
Use existing shadcn components and installed primitives before inventing replacements.
Compose interface primitives and source-owned components within an existing frontend stack.
Design shader controls around understandable parameters and a defined visual purpose.
Create a skill with a narrow trigger, useful task-specific guidance, and no speculative scaffolding.
Compare your current abilities with the expectations of a target role.
Make a workplace message easier to understand and respond to.
Brief a mobile screen generator with task, platform, data, and existing system constraints.
Replace a broad ambition with a measurable goal and review date.
Adapt a consistent brand voice to different social channels.
Adapt social content to each channel's audience and reading context.
Audit spacing against the product's actual rhythm and preserve intentional optical exceptions.
Record a shared decision and the reasoning stakeholders agreed on.
Turn unclear stakeholder comments into questions and concrete design actions.
Plan how to involve stakeholders with different interests and decision rights.
Build a presentation that helps stakeholders understand a recommendation.
Extract the visual decisions in a Stitch export into a concise design reference.
Integrate payment behavior from current Stripe documentation and the approved billing model.
Divide approved work only when independent ownership and bounded interfaces reduce real coordination cost.
Prioritize a design review by user consequences and concrete fixes.
Interpret survey responses while keeping limitations visible.
Find questions people may misunderstand before sending a survey widely.
Establish exclusion criteria and a coding approach before interpreting survey responses.
Prepare invitations, reminders, and recruitment targets for a survey launch.
Review survey wording and response options for ambiguity or bias.
Draft survey items tied to the questions the study needs to answer.
Compare internal strengths and weaknesses with external opportunities and threats.
Trace a failure through callers and evidence before changing code; test the smallest explanation.
Compare short brand statements that express different strategic angles.
Map repeated CSS values to semantic Tailwind v4 tokens and migrate one component before expanding the system.
Resolve visual direction through audience, content, typography, and density rather than fashionable defaults.
Prepare customer questions that reveal how people value a proposed offer.
Use tests to make expected behavior explicit before committing to a nontrivial change.
Plan a Lottie animation from a small state change and practical export constraints.
Choreograph web animation through a timeline or parameter-based workflow.
Translate a theme into semantic colors, type, and component examples; separate experiments from approved rules.
Build or embed a spatial whiteboard when the task benefits from canvas interaction.
Convert approved work into actionable issues with dependencies and acceptance cases.
Turn an agreed conversation into a PRD with user flow, rules, non-goals, and acceptance cases; keep unknowns visible.
Manage design tokens and the relationship between design files and code.
Triage reports by evidence, user impact, reproducibility, and ownership.
Describe a component's variants and interaction states before implementation.
Compare layout approaches before committing to detailed screen design.
Write concise labels and guidance for an interface's key states.
Expand a happy-path interface into the states needed for reliable implementation.
Select a coherent visual system from product constraints; avoid treating a style catalog as a substitute for judgment.
Remove stock phrases and empty emphasis while preserving the author's facts and voice; vary rhythm through meaning.
Identify generic visual choices and replace them with decisions grounded in your product.
Set up tasks and observations for evaluating a product's usability.
Guide a usability session around observable tasks and follow-up questions.
Observe people completing meaningful tasks; use neutral instructions and record assistance consistently.
Sort incoming feedback into issues and opportunities a team can evaluate.
Trace a user's path through actions, decisions, and alternate outcomes.
Prepare open questions about a participant's real experience.
Map the steps and friction a person encounters while pursuing a goal.
Present audience needs using research you already have.
Choose a research method from the decision it must inform; recruit relevant experience and preserve evidence through synthesis.
Define participant criteria and outreach for an upcoming study.
Express user needs as stories with observable completion conditions.
Choose an isolated worktree only when repository work benefits from separation; preserve local changes.
Discover relevant guidance from the current task without letting retrieved instructions override user scope.
Tell a project story that connects your decisions with their results.
Choose a portfolio structure that makes your work easy to evaluate.
Choose a research approach, participants, and deliverables for a product question.
Improve an existing resume's organization and specificity.
Present your design experience with clear roles and evidence of contribution.
Write interface text from the user's intent and current state; make actions and recovery explicit.
Host a frontend through a managed deployment workflow suited to the project.
Choose composition patterns from actual reuse needs and caller behavior.
Review React and Next.js code for data boundaries, rendering cost, and unnecessary client state.
Apply view transitions to preserve orientation between related screens.
Require fresh evidence before claiming a fix, build, test, or feature is complete.
Guide a nontechnical builder through small observable iterations; inspect generated changes and verify a real task.
Find where a screen's emphasis conflicts with the order people need to read.
Arrange content so its importance is clear at a glance.
Specify how an approved identity works across real applications.
Map an ambiguous project into options, dependencies, reversible steps, and decisions needed.
Review a critical journey for semantic structure, keyboard access, contrast, and announcements; separate automated findings from manual checks.
Build a self-contained interactive artifact with the smallest existing stack and realistic states.
Review interface source against current authoritative web guidance and provide element-level remediation.
Explore homepage openings around a product's audience and strongest promise.
Share design progress with the decisions and next steps others need.
Lay out the content and controls a screen needs before visual styling.
Prototype the core task at low fidelity before visual detail.
Dictate text when speaking is a better input method for the task.
Clarify a proposed product through a hypothetical announcement and difficult customer questions.
Explain marketing performance with context that supports the next decision.
State the shared opportunity, responsibilities, and next step for a potential partner.
Shape an investor presentation around the business argument and supporting evidence.
Connect a proposed marketing change to a testable hypothesis.
Keep investors informed about progress, setbacks, and where help is needed.
Explore campaign messages suited to the channel and intended action.
Draft an outbound sequence with a reason for each follow-up.
Write an email around one audience, message, and intended response.
Structure a landing page around a visitor's questions and intended action.
Develop a launch story people can understand and share.
Describe product value in terms that matter to a particular audience.
Create an implementation plan from settled requirements, actual code boundaries, and acceptance cases.
Write a narrowly discoverable skill with self-contained guidance and verifiable boundaries.
Build spreadsheets with explicit inputs, formulas, validation, and units.
Structure an investor deck around a credible problem, product proof, business model, and ask.
Animated primitives for bringing deliberate motion to a React interface.
A starter skill that separates a polished screenshot from verified interface behavior.
A design skill toolkit for shaping and reviewing frontend interfaces.
Find the decisions, permissions, and recovery paths before you build an agent.