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?"
tools
Building resilient distributed systems with circuit breakers, retries with full-jitter exponential backoff, retry budgets (per-request 3-attempt + per-client 10% ratio per Google SRE), deadline propagation, and the cascading-failure math (4 layers × 3 retries = 64x amplification). Grounded in Resilience4j, Microsoft Cloud Patterns, AWS Architecture Blog (Marc Brooker), and Google SRE Book.
testing
Designing HTTP cache headers that work correctly across browsers, CDNs, and shared proxies — `Cache-Control` directives per RFC 9111, `stale-while-revalidate` and `stale-if-error` per RFC 5861, the Vary header for varying responses, and surrogate keys for tag-based purging. Grounded in IETF RFCs and Cloudflare/Fastly docs.
development
Use when designing or fixing a Content Security Policy on a real site, choosing between nonce-based and hash-based CSP, adding strict-dynamic, debugging "Refused to execute inline script" errors, deploying CSP in report-only mode first, configuring report-to / report-uri, or auditing an existing policy for unsafe-inline / unsafe-eval / wildcards. Triggers: "CSP blocks legitimate inline script", strict-dynamic, nonce-{RANDOM}, sha256-{HASH}, object-src none, base-uri none, frame-ancestors, Trusted Types, X-Content-Security-Policy obsolete, report-only vs enforced. NOT for general HTTP security headers (HSTS, COOP/COEP), Trusted Types deep dive, CORS configuration, or building a WAF.
tools
Choosing and operating an HTTP API versioning strategy that doesn't break clients — Stripe's date-based pinned versions, the Deprecation/Sunset header pair (RFC 9745 + RFC 8594), URI vs header vs media-type approaches, and the version-transformer pattern. Grounded in Stripe's published architecture and IETF RFCs.