human-processor-model
À propos
Cette compétence applique le Modèle du Processeur Humain (MHP) pour estimer rapidement les temps d'exécution des tâches et identifier les goulots d'étranglement d'utilisabilité comme la charge cognitive ou les délais moteurs. Les développeurs peuvent l'utiliser pour comparer des conceptions d'interface, auditer les charges mémorielles et évaluer des prototypes sans études utilisateurs. Elle fournit un flux de travail structuré pour analyser les coûts d'interaction dans les parcours produits.
Installation rapide
Claude Code
Recommandénpx skills add raintree-technology/claude-starter -a claude-code/plugin add https://github.com/raintree-technology/claude-startergit clone https://github.com/raintree-technology/claude-starter.git ~/.claude/skills/human-processor-modelCopiez et collez cette commande dans Claude Code pour installer cette compétence
Documentation
Human Processor Model
Use this skill to make a fast, explicit usability estimate from a concrete task. The goal is not false precision; it is to expose where perception, cognition, memory, or motor action makes the flow slow or fragile.
Inputs
Collect or infer:
- Target user and relevant constraints: novice/expert, older adult, motor impairment, low vision, stress, interruption risk.
- The exact task goal and success state.
- The current method: screens, controls, labels, data entry, navigation path, and feedback.
- Competing method, if the user wants a comparison.
If the UI is not provided, ask for the smallest missing artifact that determines the steps: screenshot, route, prototype, task list, or current implementation path.
Workflow
- Define one narrow task, for example "create a refund for order 1042" rather than "use the billing app".
- Write the observable user steps from start state to success state.
- Break each step into perceptual, cognitive, motor, and memory operations.
- State assumptions before calculating: user expertise, reading load, device, input method, error-free path, and whether information can remain visible.
- Estimate each operation with the defaults below, adjusting only when the interface or user population justifies it.
- Sum the time and call out bottlenecks separately from the numeric total.
- Recommend changes that remove whole operations, keep needed information visible, reduce mode switches, or make feedback immediate.
Default Estimates
Use these as rough planning constants:
| Operation | Default |
|---|---|
| Eye movement or visual target acquisition | 230 ms |
| Perceptual processor cycle | 100 ms |
| Cognitive processor cycle | 70 ms |
| Motor processor cycle | 70 ms |
| Visual image storage half-life | 200 ms |
| Auditory storage half-life | 1500 ms |
| Working-memory effective capacity | 5-9 chunks |
| Working-memory practical capacity | about 3 chunks |
Use a range instead of a single number when the UI is underspecified or the user group changes the estimate. Older, distracted, impaired, or unfamiliar users usually need slower cycle assumptions and more recovery time.
Memory Risk
Flag memory risk when the user must retain:
- More than 3 unrelated chunks.
- A value that disappears before it is used.
- A code, date, name, or identifier while continuing to read or navigate.
- A decision rule hidden in prior copy.
When a recall probability estimate is useful, model decay qualitatively unless the task provides a clear elapsed time and known memory type. Prefer design fixes over math: keep the source value visible, duplicate it near the destination, or convert recall into recognition.
Output
For audits, structure the answer as:
- Task modeled.
- Assumptions.
- Step table with operation type, estimate, and issue.
- Total best estimate or range.
- Top bottlenecks.
- Design changes ranked by removed operations or reduced memory burden.
For comparisons, show both methods with the same assumptions and highlight the operation count delta, not just the final time.
Guardrails
- Do not present estimates as study results.
- Do not invent empirical validation.
- Do not optimize only for speed when safety, confidence, accessibility, or error prevention matters more.
- If the flow is high-stakes, recommend observing real users after the model narrows the hypotheses.
Dépôt GitHub
Compétences associées
executing-plans
DesignUtilisez la compétence executing-plans lorsque vous disposez d'un plan de mise en œuvre complet à exécuter par lots contrôlés avec des points de contrôle de revue. Elle charge et examine le plan de manière critique, puis exécute les tâches par petits lots (3 tâches par défaut) tout en rapportant la progression entre chaque lot pour une revue par l'architecte. Cela garantit une mise en œuvre systématique avec des points de contrôle de qualité intégrés.
requesting-code-review
DesignCette compétence délègue un sous-agent réviseur de code pour analyser les modifications apportées au code par rapport aux exigences avant de poursuivre. Elle doit être utilisée après avoir terminé des tâches, implémenté des fonctionnalités majeures, ou avant une fusion vers la branche principale. La revue aide à détecter précocement les problèmes en comparant l'implémentation actuelle avec le plan initial.
connect-mcp-server
DesignCette compétence fournit un guide complet permettant aux développeurs de connecter des serveurs MCP à Claude Code via les transports HTTP, stdio ou SSE. Elle couvre l'installation, la configuration, l'authentification et la sécurité pour intégrer des services externes tels que GitHub, Notion et des API personnalisées. Utilisez-la lors de la configuration d'intégrations MCP, de la configuration d'outils externes ou du travail avec le Protocole de Contexte de Modèle de Claude.
web-cli-teleport
DesignCette compétence aide les développeurs à choisir entre les interfaces Web et CLI de Claude Code en fonction de l'analyse des tâches, puis permet une téléportation transparente des sessions entre ces environnements. Elle optimise le flux de travail en gérant l'état et le contexte de la session lors du passage entre le web, la CLI ou le mobile. Utilisez-la pour des projets complexes nécessitant différents outils à diverses étapes.
