skills/stanton-2006-hierarchical-task-analysis/SKILL.md
Hierarchical Task Analysis methodology for decomposing complex tasks into structured subtask hierarchies
npx skillsauth add curiositech/windags-skills stanton-2006-hierarchical-task-analysisInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
license: Apache-2.0
Load this skill when facing:
HTA describes what the system must achieve (goals), not what people currently do (tasks). A goal is measurable: "temperature maintained within 5°C of setpoint" not "operator monitors temperature." This distinction is profound:
The shift: From "document what happens" to "specify what must be accomplished."
Plans are control structures, not sequences. They specify:
Plans answer: "When does this matter? What triggers it? How do you know you're done?" They encode the contextual intelligence about goal relationships. Without plans, you just have a list. With plans, you have a control model.
Stop decomposing when (Probability of inadequate performance) × (Cost of inadequate performance) is acceptable. This principle:
The discipline: Not "analyze everything to the same depth" but "analyze where failure matters most."
These principles prevent HTA from degenerating into procedural flowcharts. They maintain the discipline of goal-directed analysis.
The sub-goal hierarchy is a substrate for multiple analyses, not an end product. Once you have the goal structure and plans:
The leverage: Build the goal framework once, annotate it for many purposes.
IF you're documenting how things currently work
THEN you're probably doing task analysis, not HTA—shift to specifying what must be achieved
IF your analysis reads like a procedure manual
THEN you've lost the goal-based perspective—reframe in terms of measurable achievements
IF you can't specify success criteria for a "sub-goal"
THEN it's probably an activity description, not a goal—ask "what does this accomplish?"
IF the sub-goal is routine and failure consequences are minor
THEN stop—mark as "adequate" and move to higher-variance components
IF the sub-goal has high error variance OR high failure cost
THEN continue decomposition until you understand failure modes
IF you're decomposing because "it feels incomplete"
THEN you're probably over-analyzing—apply the P×C rule explicitly
IF subject matter experts say "anyone can do that part"
THEN that's a signal to stop—focus on the non-obvious elements
IF your plan is just a sequence (do 1, then 2, then 3)
THEN you're missing control logic—identify decision points and conditions
IF you can't specify what triggers each sub-goal
THEN you don't understand the coordination—interview experts about context
IF the plan has no contingencies
THEN you're describing the ideal case only—probe for "what if X goes wrong?"
IF experts disagree about the plan
THEN you've found important variance—document both strategies and conditions for each
IF designing training
THEN focus on high P×C sub-goals and complex plan structures (→ load hta-as-springboard-for-specialized-analysis.md)
IF predicting errors
THEN examine each sub-goal for failure modes and each plan for coordination breakdowns (→ load failure-modes-and-error-variance.md)
IF designing interfaces
THEN identify information requirements at each plan decision point (→ load the-gap-between-knowing-and-doing.md)
IF allocating functions
THEN examine which sub-goals require human judgment vs. algorithmic control
IF you're stuck choosing between abstraction levels
THEN consider multiple parallel analyses at different levels (→ load hierarchies-of-abstraction-enable-action.md)
| Reference File | When to Load | Key Content |
|----------------|--------------|-------------|
| goal-decomposition-as-problem-solving-substrate.md | When you need to understand WHY goal-based analysis is fundamentally different from task description; when justifying HTA to stakeholders | The theoretical distinction between goals and activities; why solution-neutrality matters; how the same HTA supports multiple applications |
| stopping-rule-and-analytical-economy.md | When deciding how detailed your analysis should be; when facing scope creep; when stakeholders want "complete" documentation | The P×C rule explanation; practical guidance on stopping criteria; why "adequacy" is the right standard; handling analytical effort strategically |
| plans-as-coordination-intelligence.md | When writing plans; when sub-goals seem like a flat list; when analyzing decision-making or coordination | What plans actually are; how they encode control logic; examples of conditional, parallel, and iterative plans; why plans are where expertise lives |
| hta-as-springboard-for-specialized-analysis.md | When moving from HTA to training design, error prediction, or interface design; when HTA feels like "just documentation" | How to extend HTA with additional columns; examples of tabular annotations; the framework pattern that makes HTA valuable |
| three-governing-principles-of-goal-based-systems.md | When your analysis feels unprincipled; when teaching HTA; when someone challenges whether HTA is "theory" or just notation | The three principles; how they derive from control theory; why they prevent common degenerative patterns; theoretical grounding |
| failure-modes-and-error-variance.md | When designing for reliability; when analyzing incidents; when applying SHERPA or similar error prediction methods | How to identify error modes systematically; the relationship between goals and failure; error variance as a design driver |
| the-gap-between-knowing-and-doing.md | When designing interfaces, job aids, or information systems; when people "know what to do but don't do it" | Information requirements at each sub-goal; the distinction between knowledge and executable understanding; what information must be available when |
| hierarchies-of-abstraction-enable-action.md | When struggling with the "right" level of analysis; when different stakeholders need different views; when detail obscures comprehension | How abstraction level affects usefulness; the problem of completeness vs. comprehensibility; strategies for multi-level analysis |
Symptom: Your "HTA" is just numbered steps with no goal statements or success criteria
Why it fails: Loses solution-neutrality, can't support multiple applications, provides no basis for improvement
Antidote: For each "step," ask "what does this achieve?" and "how would you know if it succeeded?"
Symptom: Spending equal effort on high-variance critical sub-goals and routine trivial ones
Why it fails: Wastes analytical effort, obscures what matters, creates maintenance burden
Antidote: Apply P×C rule explicitly; mark adequate sub-goals and move on
Symptom: Writing plans as "do 1, 2, 3" after building the hierarchy
Why it fails: Misses the control intelligence; plans and goals should co-evolve
Antidote: When decomposing a goal, immediately ask "under what conditions does each sub-goal matter?"
Symptom: "Sub-goals" like "operator presses button" or "system displays screen"
Why it fails: These describe implementation, not achievement; no success criteria
Antidote: Reframe as "temperature setpoint updated" or "alarm condition communicated to operator"
Symptom: Producing the hierarchy diagram and calling it done
Why it fails: Misses the entire point—HTA is infrastructure for further analysis
Antidote: Always ask "what decision does this HTA support?" and extend it for that purpose
Symptom: Belief that HTA is "done" when every leaf node is equally detailed
Why it fails: Completeness is not the goal; analytical economy is
Antidote: Stopping is a principled decision, not a failure; document why you stopped at each node
Symptom: Analyzing to arbitrary depth without considering where failures actually occur
Why it fails: Allocates effort uniformly rather than strategically
Antidote: Gather empirical data or expert judgment about error frequency and consequences
Remember: HTA is not notation—it's a theory of goal-directed performance grounded in control theory. The hierarchy describes what must be achieved. The plans describe how achievement is controlled. The P×C rule directs analytical effort. The three principles maintain discipline. The tabular extensions enable application-specific analysis. When you find yourself lost, return to the question: "What must be accomplished, and how will we know if it succeeded?"
data-ai
license: Apache-2.0 NOT for unrelated tasks outside this domain.
development
Use when designing caching strategies (cache-aside, write-through, write-behind), implementing distributed locks, building rate limiters, leaderboards, real-time streams (XADD/consumer groups), pub/sub, or tuning eviction policies. Triggers: thundering-herd on cache miss, dogpile on key expiry, Redlock vs SET-NX-PX choice, sliding-window rate limiter, hot-key on a single cluster slot, big-key blowup, MULTI/EXEC across slots, KEYS in production. NOT for Redis Cluster operations/admin (different domain), embedded KV (SQLite, leveldb), in-process LRU caches, or Memcached.
tools
Drawing the `'use client'` boundary correctly in React Server Components apps (Next.js App Router, RSC frameworks) — leaf-pushing, slot composition, serialization rules, and environment poisoning prevention. Grounded in react.dev and Next.js 16 docs.
development
Use when designing rate limiting for an API, choosing between token bucket / sliding window / leaky bucket / fixed window, implementing it in Redis, deciding edge (Cloudflare/Upstash) vs origin enforcement, sizing per-user vs per-IP vs per-endpoint quotas, returning the right 429 response with Retry-After, or fixing the boundary-burst bug in fixed-window limiters. Triggers: 429 too many requests, INCR + EXPIRE, ZADD + ZREMRANGEBYSCORE + ZCARD, X-RateLimit-Remaining header, Cloudflare WAF rate limiting rules, Upstash @upstash/ratelimit, leaky bucket shaping vs policing, distributed rate limiter consistency. NOT for DDoS mitigation specifically (different scale), CAPTCHA / bot management, full WAF design, or per-user quota billing.