VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

How Procedure Steps Work | Turn Intent Into Observable Action

Three secondary students review open books and notes together in a classroom.

Procedure steps work when they convert an intention into actions an intended user can perform, observe and complete.

A sentence can be grammatically clear while still being operationally weak. ‘Review the work carefully’ sounds reasonable, but it hides what to inspect, what standard to use, what counts as an error and what should happen after one is found.

A strong step exposes the decision that actually moves the task forward.

This is the first pillar of How Procedures Fail.


The Core Model: Action, Object, Condition, Evidence

A useful step can be tested with four questions.

  • Action — what does the user do?
  • Object — what is the action applied to?
  • Condition — when or under what rule should it happen?
  • Evidence — what proves the step is complete?

Not every line needs four labels. The designer should still be able to answer all four.


Start With the State Change

Ask what becomes different after the step.

If nothing observable changes, the line may be advice, explanation or policy rather than an executable step.

‘Think carefully’ does not define a state change. ‘Underline the command word and write the required output beside it’ does.


Use Verbs That Expose Action

Strong procedural verbs reduce interpretation cost.

  • Open the source file.
  • Compare the two values.
  • Record the result.
  • Select the matching category.
  • Reattempt the question.
  • Stop the process.
  • Escalate the unresolved case.

Formal language is not automatically precise language. The best verb is the one that matches what the user actually does.


Name the Object

Ambiguous pronouns become expensive after interruptions.

‘Check it’ can mean the answer, the file, the link, the version or the whole document.

Name the object when a reasonable user could choose the wrong one.


Put Conditions Before Irreversible Actions

Some actions are valid only after approval, only above a threshold, only when prerequisites are stable or only before a deadline.

The condition should appear before the action that depends on it.

This prevents a correct action being executed at the wrong time.


Split Actions That Can Fail Independently

A line such as ‘download, review, correct and submit’ contains four states.

If one part can fail while the others succeed, the procedure should make the boundaries visible.

This also helps users resume after interruption.


Do Not Over-Fragment

Atomicity has a limit. Writing every mouse click as a separate instruction can bury the actual decisions.

The useful unit is the smallest action that carries a meaningful state change, risk, decision or handoff.


Sequence by Dependency

Order should follow what must be true before the next action can work.

A learner must understand a method before transfer can be tested. An editor must choose the canonical owner before publishing a new article. A student must finish an attempt before an independent check can test it.

Dependency gives sequence its logic.


Expose Decision Points

Many procedures are not straight lines.

Use observable branches: if the condition is present, continue; if not, repair, stop or route elsewhere.

A hidden branch becomes improvisation.


Define Completion

A step should help the user know when to move on.

Completion might be a value inside range, an approved document, a successful test, a submitted file or an independent performance.

Without a completion state, people stop too early or continue too long.


Build Verification Into Critical Steps

The most valuable checks sit near points where error would become expensive or propagate.

This connects directly with How Critical Checks Work and How Checklist Verification Works.


Write for Resumption

A step should still make sense after the user has been interrupted.

Visible outputs, explicit objects and numbered states help the user restart safely.


Do Not Hide Judgment Inside ‘Review’

Review is often a container word.

If the real skill is comparing evidence, selecting a method or finding the first invalid line, write that decision.

  • Compare the claim with the cited source.
  • Identify the first line where the solution becomes invalid.
  • Check whether every required stimulus detail is represented.
  • Decide whether the learner can complete a fresh task without the prompt.

Use Examples and Non-Examples

When a quality boundary is difficult to describe, examples can make the step usable.

Show one strong case, one near miss and one unacceptable case. The learner sees the boundary rather than memorising a single surface.


Test With the Same Tools and Permissions

A procedure can be perfectly written and still fail because the real user cannot see the menu, access the folder or use the function the author assumed.

Run the steps in the actual environment.


Test With a Cold User

Give the procedure to someone who did not help write it.

Observe where they hesitate, what they ask and which reasonable misinterpretation they choose.

Those moments reveal hidden assumptions.


Example: Mathematics

Weak: ‘Check your answer.’

Stronger: ‘Substitute the final value into the original equation. If both sides match, keep the answer. If not, inspect the first transformation involving signs, brackets or fractions.’

Bukit Timah Tutor’s How Checking Works in PSLE Mathematics applies this principle using independent evidence.


Example: English

Weak: ‘Proofread carefully.’

Stronger: ‘Read only for sentence boundaries first. Mark any sentence containing two complete clauses without valid joining punctuation. Repair those before checking spelling.’

SETC’s Proofreading Under Exam Pressure shows why final checking should search for high-value errors rather than reread vaguely.


Example: Independent Learning

Weak: ‘Revise algebra.’

Stronger: ‘Attempt three mixed questions without notes, classify the first meaningful error, repair that cause, then return to one changed question after a delay.’

eduKate Sengkang’s How Independent Learning Works treats independence as the transfer of next-step decisions from teacher to learner.


The Step Design Test

  • What state changes?
  • Is the action visible?
  • Is the object unambiguous?
  • Is the condition clear?
  • Does sequence follow dependency?
  • Are branches explicit?
  • Is completion observable?
  • Can the user resume after interruption?
  • Does the step fit the real time and tools?
  • Can a cold user execute it without hidden rescue?

Procedure steps work when the user does not need to reverse-engineer the author’s mind in order to act.


Across the eduKate Ecosystem

Across the eduKate ecosystem, eduKateSingapore Project Atlas maps ownership; eduKate Sengkang develops independent learning; eduKate Punggol carries family-facing routines; Bukit Timah Tutor applies verification to Mathematics; SETC carries English examination independence; and eduKate Yishun carries recovery, escalation and rebuild decisions.


Sources and Further Reading

UK Health and Safety Executive — Procedures and Human Factors

NASA / FAA — Human Factors Design Standard

Federal Aviation Administration — The Use and Design of Flightcrew Checklists and Manuals


Continue the Series

How Procedures Fail | Why Correct Instructions Still Break in Real Work

How Procedure Exceptions Work | Handle Non-Standard Cases Without Breaking the Standard

How Procedure Version Control Works | Keep the Current Method Current, Traceable and Usable

eduKateSG