DETAKAI
Start an assessment↗
Insights/Architecture

Systems architecture / Detakai field note

Pick the level of intelligence the problem needs

Four ways to solve a problem — human judgment, rules, ML, and generative AI — and how to choose the right one per task instead of treating AI as a universal fix.

28 July 20268 min readSystems architecture · Machine learning · Generative AI · Risk
PRIMARY OUTCOME / FIELD NOTE

A decision framework for matching each task to the simplest intelligence that solves it.

INTELLIGENCE SELECTIONA decision framework—not a benchmark or claimed client result.

  1. 01
    Solution tiers

    Human · Rules · ML · GenAI

  2. 02
    Selection principle

    Simplest fit wins

  3. 03
    Human oversight

    Ethics + liability

  4. 04
    Typical system

    Hybrid by default

AI is sold as a ladder: start with rules, graduate to machine learning, and arrive at generative AI. That framing is wrong, and it is expensive.

The four ways of solving a software or data problem are not rungs on a progression. They are different tools. Human judgment, deterministic code, statistical models, and generative systems each carry their own accuracy, cost, complexity, and risk profile. A working architecture picks the tool that fits the task — and often combines several rather than betting on one.

Most technology projects do not fail because a model was weak. They fail because the wrong system type was chosen for the job.

The four approaches are alternatives, not a ladder

Treat these as four distinct options on a shelf, not four steps upward:

  • Human judgment — nuanced decisions requiring ethics, accountability, and tolerance of ambiguity.
  • Deterministic rules and code — explicit logic that must behave exactly the same way every time.
  • Machine learning — probabilistic pattern recognition over structured data.
  • Generative AI — flexible synthesis, reasoning, and language work over unstructured data.

The mistake is assuming “more advanced” means “more appropriate.” A payment validator does not become better because a language model touches it. A hiring decision does not become safer because a rule replaced the human.

Human judgment for ambiguity, ethics, and accountability

Humans are the right owner when the task is nuanced, ethically loaded, or carries liability.

Medical diagnosis, hiring, legal interpretation, and financial strategy share a property machines lack: the capacity to hold ambiguity, weigh competing values, and be held accountable. When a decision can create legal exposure or significant harm, keeping a person in the loop is usually the point — not a fallback.

The cost is real. Human review is expensive, slow, and hard to scale. That is the trade-off to accept deliberately, not a defect to engineer away.

Deterministic rules for fixed logic at scale

Rule-based and code-based solutions win when the logic is explicit, stable, and must produce exact, repeatable output.

Payment processing, input validation, and security checks belong here. An error is unacceptable, so the behaviour must be deterministic and debuggable. These systems are fast, cheap, reliable, and easy to reason about.

Applying AI to this class of problem usually adds complexity and risk where a simple rule would have sufficed. If you can write the logic, write the logic.

Machine learning for pattern recognition

Machine learning earns its place when manually written rules cannot capture an evolving pattern in structured data.

Fraud detection, churn prediction, and demand forecasting are typical fits: the signal is real but non-obvious, and it shifts faster than a human-maintained rule set. Models scale efficiently once trained.

Two constraints matter. First, models drift, so they need ongoing monitoring and retraining. Second, they explain poorly — a probability is not a logical narrative. Keep ML away from tasks that require a reasoned, auditable chain of cause and effect.

Generative AI for flexible reasoning

Generative AI and large language models are strongest on unstructured data that needs synthesis, reasoning, or language interpretation.

Document summarization, code generation, and open-ended support conversations are good fits, where adaptability matters more than exact precision. These systems are flexible and can sit inside a larger workflow.

They are also non-deterministic, offer no correctness guarantee, and are the most costly to run at scale. The dependable pattern is hybrid: a model handles the flexible content step, while deterministic code and checks handle the parts where precision is not negotiable.

Match the tool to the component, not the project

Effective architecture is component-by-component. A single workflow usually needs more than one kind of intelligence, and the disciplined choice is to assign each part to the simplest thing that solves it.

A practical heuristic:

  • Humans handle ethics and high-stakes decisions.
  • Code handles fixed, exact logic.
  • Machine learning handles pattern prediction over data.
  • Generative AI handles flexible content and language processing.

Real systems are mostly hybrid: deterministic code guarding the edges, statistical models scoring the risk, and generative agents handling the unstructured steps. The architecture is the set of assignments, not the presence of a model.

A selection checklist

Before reaching for a model, answer four questions:

  1. Does this need ethical judgment or carry liability? If yes, keep a human decision-maker.
  2. Can the logic be written as explicit rules? If yes, write code — do not add a model.
  3. Is the signal a non-obvious pattern in structured data? If yes, machine learning is the candidate, with monitoring attached.
  4. Is the work unstructured synthesis or language reasoning where precision is secondary? If yes, generative AI fits — inside a guarded, hybrid flow.

When more than one answer applies, the answer is usually “both, in separate components.”

Why this prevents failures

The common failure mode is not a weak model. It is selecting the wrong system type: a model where a rule would have been safer, a rule where a human should have decided, or a human process where code would have been cheaper and faster.

Choosing the appropriate level of intelligence for each specific problem is the discipline that separates a system that scales from one that accrues cost and risk it cannot explain.

This field note presents an operating-model perspective and does not state client results or benchmark claims. References below are canonical primary sources and are unverified in this environment — confirm before publishing (live verification was unavailable when this article was drafted).

References