In 30 seconds

Most tasks are not one thing. They are several steps, some rule-based, some needing interpretation, some needing human judgment. Break the task apart so each step gets the mechanism that fits it, instead of handing the whole thing to an AI.

Why this comes up

"Handle the request with AI" treats a mixed task as a single AI job. In reality, parts of it are simple rules the AI does not need, and parts genuinely need interpretation. Lumping them together makes the workflow harder to test, harder to trust and more expensive than it needs to be.

Decomposing turns one opaque step into a sequence you can reason about.

Break the task into steps

Walk through the task and list the distinct steps. For each, ask what kind of work it is:

  • A rule: a stable decision with a clear condition. Prefer deterministic automation.
  • Interpretation: reading language or documents, classifying, extracting. This is where AI helps.
  • Human judgment: a decision that needs a person's authority or expertise.
  • An action: a change to a system or a message sent. Consider approval and reversibility here.

Label every step. The labels tell you which parts need a model and which do not.

Put the mechanisms in the right order

A common and reliable shape is: use AI to turn messy input into structured fields, then let rules handle the structured decisions, then gate any consequential action behind a person.

UNSTRUCTURED INPUT
      ↓
AI extracts / classifies (interpretation)
      ↓
RULES check the structured result (deterministic)
      ↓
PERSON approves the consequential action (judgment)
      ↓
SYSTEM executes and logs (action)

Each mechanism does the part it is best at.

A small example

"Process incoming invoices with AI" decomposed into: extract fields from the PDF (AI), match to a purchase order by reference (rule), check the amount is within tolerance (rule), and approve anything unusual (person). Only the first step needed a model. The rest became simple, testable rules.

What this does not solve

Decomposition clarifies what each step needs; it does not remove the need to design authority, handle exceptions or test the whole flow. It makes those later steps possible by giving you parts small enough to reason about.

Good enough to move on when

  • The task is broken into distinct steps.
  • Each step is labelled rule, interpretation, judgment or action.
  • Only the interpretation steps rely on AI.
  • Consequential actions are separated out for approval and logging.