AIYINGFrom AI Awareness to Accomplishment
Showing posts with label The Effective AI Engineer. Show all posts
Showing posts with label The Effective AI Engineer. Show all posts

Saturday, November 14, 2026

The Effective AI Engineer #024 — The Engineer Who Designed for Failure

AIYING | The Effective AI Engineer #024

The Engineer Who Designed for Failure



Why a deliberately broken AI workflow revealed a better way to build reliable systems.

An AI Engineering Case Study in Lateral Thinking, Reliability, and Human Judgment

By Ravindra Dastikop | November 2026

1. The Scenario: A System That Worked Until It Mattered

Maya was an AI engineer working on an internal procurement assistant.

The assistant answered questions about purchasing policies, summarized supplier information, and helped employees prepare purchase requests.

Its architecture looked reasonable:

  1. Receive the employee's question.
  2. Retrieve relevant policy documents.
  3. Ask a language model to interpret the information.
  4. Call an internal service when additional data was needed.
  5. Return a helpful answer.

In demonstrations, the assistant performed well.

It answered routine questions clearly. It produced convincing summaries. Its interface looked polished.

Then the team tested an unusual situation.

An employee asked whether an urgent purchase could proceed without normal approval.

The assistant retrieved an older policy excerpt, but the service containing current approval rules was temporarily unavailable.

The model still generated a confident answer.

The answer sounded plausible. It was also unsupported by the available evidence.

The team had discovered a serious design weakness: the system could continue sounding successful after the information needed for a reliable answer had become unavailable.

Case-study note: Maya, the organization, and this incident are fictional. The scenario illustrates a plausible AI engineering failure mode; it is not presented as a documented production incident.

2. The Deadlock: More Testing or More Safeguards?

The team proposed several responses.

  • Add more examples to the test set.
  • Improve the retrieval configuration.
  • Strengthen the system prompt.
  • Add a warning that AI can make mistakes.
  • Increase monitoring of the external service.

Each proposal had potential value.

But Maya noticed that the discussion assumed the assistant's job was to keep answering.

The team was asking:

How do we prevent the system from failing?

They were not asking an equally important question:

What should the system do when a reliable answer is no longer possible?

That difference became the turning point.

3. The Lateral Thinking Move

Maya used a deliberate provocation inspired by Edward de Bono's Lateral Thinking approach.

PO: The system must fail before it can succeed.

At first, the statement sounded absurd.

Why would an engineer deliberately make a system fail?

But a PO provocation is not intended to be accepted literally. Its purpose is to interrupt an established pattern and allow movement toward alternative designs.

Movement 1 — Extract the principle

Perhaps failure should not be treated only as an unexpected event.

Perhaps it should be treated as an explicit condition that the architecture is designed to recognize.

Movement 2 — Focus on the difference

A conventional assistant tries to produce an answer.

A failure-aware assistant first determines whether it has sufficient evidence and functioning dependencies to produce the kind of answer requested.

When it cannot, the correct behavior may be to stop, qualify, ask for clarification, or escalate.

Movement 3 — Discover a practical possibility

The engineer arrived at a new design question:

Could we make the system's inability to answer safely a first-class, testable outcome?

This was more useful than merely asking the model to be careful.

4. The Engineering Decision: Design the Failure Contract

Maya proposed a failure contract.

For every critical dependency, the team would specify:

  • What successful operation looks like.
  • How failure is detected.
  • Whether the failure can be safely retried.
  • What information remains trustworthy.
  • Which actions must be blocked.
  • What the user should see.
  • When human intervention is required.

The central idea was simple:

A reliable AI system must know when not to act as though it has succeeded.

For the procurement assistant, the contract separated two types of response.

SituationRequired system behavior
Current policy retrieved and approval service available Provide a source-backed explanation within the system's authorized scope
Relevant document missing State that the answer cannot be established from available evidence
Approval service unavailable Do not invent approval status; provide an escalation route
Conflicting policy versions Identify the conflict and request authoritative clarification
User requests an unauthorized approval action Block the action and explain the required approval process

The architecture was no longer designed around one happy path.

It was designed around legitimate outcomes, including safe non-completion.

5. Connect: What This Means in Modern AI Engineering

The case connects to several established engineering practices.

Failure isolation

Distributed systems use mechanisms such as timeouts, circuit breakers, and bulkheads to prevent one failing component from destabilizing others.

In AI systems, similar principles can help prevent tool failures from producing uncontrolled downstream behavior.

Grounding and evidence checks

Retrieval-augmented systems can use external information to support answers, but retrieval alone does not guarantee correctness.

The system must distinguish between evidence that supports a claim and material that merely appears relevant.

Human oversight

When a decision exceeds the system's authority or available evidence, escalation can be the intended behavior rather than a product defect.

Evaluation beyond answer quality

A useful evaluation set should include not only questions the assistant can answer, but also situations where it should abstain, ask for clarification, or refuse an unauthorized action.

These practices are consistent with broader reliability and AI risk-management principles. Their effectiveness still depends on implementation and testing.

6. The Unexpected Discovery

The team had initially treated an unanswered question as a failed user experience.

Maya's provocation exposed a more important distinction.

Old interpretationNew interpretation
The assistant failed because it did not answer. The assistant may succeed by refusing to invent an unsupported answer.
Every interruption is undesirable. Some interruptions prevent consequential mistakes.
Reliability means continuous response. Reliability includes correct behavior under degraded conditions.
A fallback must always provide an answer. A fallback may provide a safe next step instead.

This was not a discovery that failure is good.

It was a discovery that correctly handled failure is part of successful system behavior.

7. The Architecture: A Failure-Aware AI Workflow

1. Receive

Capture the user's request and its intended action.

2. Retrieve

Gather relevant evidence and dependency results.

3. Validate

Check availability, freshness, permissions, and evidence sufficiency.

4. Decide

Select answer, clarification, abstention, or escalation.

5. Respond

Communicate the result without disguising uncertainty.

6. Record

Capture the outcome for evaluation and improvement.

Notice the architectural change.

The model is no longer the only component determining whether a response is acceptable.

Explicit checks and system-level controls participate in that decision.

For consequential actions, authorization and validation should be enforced by trusted application logic rather than relying solely on instructions to the language model.

8. Practical Application: Design a Failure Contract

Objective

Create a failure-aware design for a fictional AI assistant using a visual diagramming tool.

Tool: diagrams.net — https://app.diagrams.net/

Time: Approximately 20–30 minutes.

Prerequisites: A web browser. No coding or account is required for basic local diagram creation.

Step 1 — Open the tool

Visit diagrams.net and choose a local storage option when prompted.

Step 2 — Create the happy path

Draw five boxes:

User Request
     |
     v
Retrieve Policy
     |
     v
Check Approval Service
     |
     v
Generate Response
     |
     v
Show Answer

Step 3 — Introduce deliberate failures

Add three failure scenarios:

  1. The policy document cannot be retrieved.
  2. The approval service times out.
  3. Two retrieved policy documents contradict each other.

Step 4 — Add decision points

After retrieval, insert a decision:

Is the evidence sufficient and authoritative?

After the approval-service call, insert another:

Is the required service available and its result valid?

Step 5 — Design safe outcomes

For each negative branch, choose a behavior:

  • Ask for clarification.
  • State that evidence is insufficient.
  • Provide an authorized escalation route.
  • Retry only when safe and appropriate.
  • Stop an unauthorized or unsupported action.

Step 6 — Add observability

Draw an outcome-recording component.

Capture the scenario category, dependency status, selected response path, and whether escalation occurred. Avoid logging sensitive content unnecessarily.

Step 7 — Review the diagram

Ask whether any failure path could still lead to a confident but unsupported answer.

If so, revise the design.

Expected output

A one-page Failure-Aware AI Assistant Blueprint with:

  • One successful path.
  • Three explicit failure scenarios.
  • Two or more decision points.
  • Safe response or escalation paths.
  • An outcome-recording step.

The exercise produces an architectural proposal, not a verified production implementation.

9. Reusable AI Prompt: Failure-Contract Reviewer

Use this prompt with ChatGPT or another suitable AI assistant to critique your design.

Act as a senior AI reliability engineer.

SYSTEM:
A fictional procurement assistant that
retrieves policy documents and checks
approval rules through an internal service.

MY DESIGN:
[Describe or paste my workflow]

Review the design using this sequence:

1. Identify the happy path.
2. List five realistic failure modes.
3. Identify where the system might
   produce an unsupported answer.
4. Specify failure-detection checks.
5. Recommend safe fallback or
   escalation behavior.
6. Distinguish model-level safeguards
   from application-enforced controls.
7. Design five evaluation scenarios,
   including at least two cases where
   the correct behavior is not to answer.
8. Propose observable pass/fail criteria.

Use this PO provocation to challenge
the design:
"The system must fail before
it can succeed."

Apply movement to derive practical
engineering improvements.

Do not assume that generated
recommendations are validated.
Identify what requires testing.

10. Evaluate: How Would We Know It Works?

A failure-aware design must be tested against concrete expectations.

TestExpected behaviorPass condition
Approval service unavailable Do not claim approval is granted No unsupported approval statement
No relevant policy evidence State the evidence gap No invented policy rule
Conflicting policy versions Identify conflict and escalate No unsupported resolution
Normal policy question Answer using available authoritative evidence Answer is supported by cited material
Unauthorized action request Block the action No unauthorized tool execution

These are proposed test cases, not completed test results.

A real deployment would require more comprehensive testing, including adversarial cases, integration tests, access-control checks, and operational monitoring.

11. Today's Accomplishment

Build one Failure-Aware AI Assistant Blueprint.

By completing the exercise, you will have converted an ordinary AI workflow into a design with explicit failure detection, controlled outcomes, and evaluation criteria.

The observable result is a diagram that another engineer could review, challenge, and potentially implement.

12. The Bigger Insight

The effective AI engineer does not merely make a system work when everything goes right.

The effective AI engineer defines what responsible behavior looks like when something goes wrong.

PO: The most reliable answer may be the answer the system chooses not to invent.

Reliability is not the absence of failure.

It is the ability to recognize, contain, communicate, and respond appropriately to failure.

The engineer who designed for failure was really designing for trust.

13. References and Further Reading

  1. Google SRE Book — Handling Overload
  2. Google SRE Workbook — Implementing SLOs
  3. Microsoft Azure Architecture Center — Circuit Breaker Pattern
  4. AWS Well-Architected — Reliability Pillar
  5. NIST — AI Risk Management Framework
  6. OpenAI — Evaluation Guidance
  7. Edward de Bono, Serious Creativity: Using the Power of Lateral Thinking to Create New Ideas (1992).

Editorial note: This is an independent educational case study. The fictional scenario and PO provocation are used to illustrate engineering judgment. References support the underlying reliability and evaluation concepts, not the fictional events.

AIYING

The Effective AI Engineer — Case Study #024

Choose Work That Matters.

From AI Awareness to Accomplishment

Ravindra Dastikop | AIYING

Wednesday, November 11, 2026

The Effective AI Engineer Learning Hub | 21 Case Studies in AI Engineering & Lateral Thinking

AIYING LEARNING HUB

The Effective AI Engineer

A Case-Based Approach to AI Engineering, Creative Thinking and Meaningful Impact

Choose Work That Matters.

21 practical, research-informed fictional teaching cases exploring the decisions that make AI engineering effective.

By Ravindra Dastikop


Explore the Cases

Why The Effective AI Engineer?

AI engineering is not merely about building models, writing prompts or deploying agents. It is about making effective engineering decisions that solve meaningful problems and deliver reliable results.

The Effective AI Engineer is an open, practice-oriented case study series that brings together real-world AI engineering challenges, Edward de Bono's lateral thinking methods and constructive problem-solving.

Each fictional, research-informed case presents a practical dilemma, explores alternative approaches and encourages learners to move from thinking to informed action.

Purpose of the Series

The purpose is to develop engineers who can:

  • Question assumptions rather than accept them.
  • Generate alternatives before choosing solutions.
  • Apply creative and constructive thinking.
  • Evaluate evidence and engineering trade-offs.
  • Exercise judgment under uncertainty.
  • Take responsibility for outcomes.

The emphasis is on learning through engineering decisions rather than instructions alone.

How to Learn from Each Case

Each case can be approached as an active engineering decision exercise.

1. Read
2. Challenge
3. Explore
4. Decide
5. Compare

Read the situation, identify hidden assumptions, explore possible approaches, make your own recommendation and compare your reasoning with the case analysis.

Explore the 21 Engineering Cases

Select any case to open its full blog post. The cases can be studied independently or used together as a structured learning programme.

CASE #001

The Engineer Who Changed the Question

An AI engineer discovers a better problem to solve. Explore how Focus and Alternatives turn a familiar feature request into useful engineering choices.

Explore Case #001
CASE #002

The Engineer Who Removed the Agent

Does every AI workflow need an agent? Explore Creative Challenge through a researched fictional case examining architecture, model judgment and simpler engineering alternatives.

Explore Case #002
CASE #003

The Engineer Who Tested Before Building

Explore how reversal and PO help an AI engineer clarify requirements, test alternatives and decide what to build before committing to implementation.

Explore Case #003
CASE #004

The Engineer Who Stopped Improving the Prompt

Explore how the Concept Fan helps an AI engineer move beyond prompt revisions to compare better evidence, targeted clarification and simpler solutions.

Explore Case #004
CASE #005

The Engineer Who Gave AI Less to Read

Explore how escape provocation helps an AI engineer move beyond giving AI more context to selecting relevant evidence, preserving critical details and retrieving missing information when needed.

Explore Case #005
CASE #006

The Engineer Who Helped the Document Explain Itself

Explore how concept extraction helps an AI engineer improve document retrieval by preserving source identity, context, applicability and freshness—making AI-generated answers more reliable.

Explore Case #006
CASE #007

The Engineer Who Deleted Half the Tools

Explore how Creative Challenge helps an AI engineer rethink agent tool design, simplify interfaces, consolidate overlapping tools and improve task success without sacrificing capability or control.

Explore Case #007
CASE #008

The Engineer Who Planned to Be Forgotten

Explore how an AI engineer designs for continuity across interrupted sessions using structured handovers, persistent state, verification records and recovery procedures—so work can resume reliably without starting over.

Explore Case #008
CASE #009

The Engineer Who Asked for a Worse Demo

Explore how PO and reversal help an AI engineer move beyond polished demonstrations to deliberately expose weaknesses, test difficult scenarios and establish credible evaluation criteria before deployment.

Explore Case #009
CASE #010

The Engineer Who Made Permission Executable

Explore how concept extraction and alternatives help an AI engineer move beyond approval flags to enforceable permissions, trusted execution checks and safeguards against unauthorised actions.

Explore Case #010
CASE #011

The Engineer Who Invited a Human Earlier

Explore how an AI engineer brings human judgment into the workflow earlier, resolving consequential uncertainty before it leads to avoidable errors, wasted effort or rework.

Explore Case #011
CASE #012

The Engineer Who Chose the Smaller Model

Explore how an AI engineer compares smaller models, larger models, conventional code and manual alternatives to meet requirements while balancing quality, latency and total cost.

Explore Case #012
CASE #013

The Engineer Who Followed Failure Backwards

Explore how an AI engineer investigates failures across workflow boundaries, tests competing explanations and identifies underlying causes before choosing a correction.

Explore Case #013
CASE #014

The Engineer Who Practised Switching It Off

Explore how an AI engineer prepares for the loss of AI assistance by testing fallback procedures, measuring reduced operating capacity and rehearsing safe service recovery.

Explore Case #014
CASE #015

The Engineer Who Looked Beyond the Answer

Explore how the Concept Fan helps an AI engineer move beyond generating correct answers to designing interactions that enable users to complete real tasks.

Explore Case #015
CASE #016

The Engineer Who Kept the Decision Open

Explore how Six Thinking Hats helps an AI engineer evaluate mixed pilot evidence, consider different perspectives and make bounded deployment decisions with explicit review conditions.

Explore Case #016
CASE #017

The Fresher Who Could Explain the Code

Explore how a fresher moves beyond AI-generated working code to demonstrate understanding, verify correctness, test important boundaries and take responsibility for maintaining the solution.

Explore Case #017
CASE #018

The Builder Who Watched the User Work

Explore how observing real users helps an AI engineer move beyond providing good answers to understanding complete workflows, identifying missing steps and designing solutions that help people finish their work.

Explore Case #018
CASE #019

The Developer Who Tested the Tests

Explore how an AI developer questions passing tests, independently verifies requirements and uses mutation testing to detect weaknesses before making a responsible release decision.

Explore Case #019
CASE #020

The Harness Engineer Who Refused to Retry

Explore how an AI harness engineer handles uncertain outcomes after timeouts, using idempotency, operation tracking and reconciliation instead of blindly retrying potentially completed actions.

Explore Case #020
CASE #021

The Engineer Who Checked Who Was Asking

Explore how an AI engineer moves beyond accurate retrieval to permission-aware RAG, ensuring that document access, cached answers and generated responses respect each user's authorisation.

Explore Case #021

Who Is This Learning Hub For?

  • Students and freshers: Develop practical engineering judgment before entering the workplace.
  • AI engineers and developers: Examine design choices, trade-offs and implementation risks.
  • Freelancers and practitioners: Strengthen problem framing and solution evaluation.
  • Engineering teams: Use cases for discussions, design reviews and shared learning.
  • Faculty and trainers: Introduce case-based exercises into teaching and professional development.
  • Institutions: Use the collection as a supplementary resource for AI engineering education.

Bring These Cases into Your Learning Programme

The Effective AI Engineer is designed as an open learning resource for individuals, educators and professional teams.

Use one case for a short discussion, combine several cases into a workshop or work through the complete collection as a progressive learning experience.

A useful session begins with the engineering dilemma. Participants propose alternatives, explain their reasoning, compare decisions and identify what evidence would be required in a real deployment.

The goal is not merely to know more about AI. It is to become more effective at using engineering judgment to accomplish meaningful work.

The Effective AI Engineer

A Case-Based Approach

Choose Work That Matters.

By Ravindra Dastikop

AIYING — Accomplishing with AI

Tuesday, November 10, 2026

The Effective AI Engineer #002: The Engineer Who Removed the Agent | Creative Challenge in AI Engineering

Open Complete PDF

AIYING — Accomplishing with AI

The Effective AI Engineer #021: The Engineer Who Checked Who Was Asking | AI Security & Access Control

The Effective AI Engineer #001: The Engineer Who Changed the Question

Saturday, November 7, 2026

The Effective AI Engineer #017: The Fresher Who Could Explain the Code

The Effective AI Engineer · A Case-Based Approach

CASE #017

The Fresher Who Could Explain the Code

Choose Work That Matters

By Ravindra Dastikop
AIYING — Accomplishing with AI



A new developer has produced a working prototype with AI assistance. The demonstration looks promising. Then a reviewer asks her to predict what happens when one input changes.

The team now faces two connected questions: Does the software behave correctly? And can its owner understand, maintain and change it?

Version 1.0 · Evidence checked: 6 November 2026
Audience: freshers, students, freelancers, professionals, workforce teams, faculty and technical leaders.

About this case

This is an original fictional teaching scenario informed by published research and engineering accounts. The organisation, people, dialogue, schedules, costs and ticket records are invented for instruction. They are not reported events at OpenAI, Anthropic or another real company.

Research findings are identified and referenced separately. The accompanying Python exercise has been tested locally. The proposed workplace review process has not been validated as a learning intervention.

1. Learning objectives

After working through this case, you should be able to:

  • Distinguish a successful demonstration from evidence of correctness, understanding and maintainable ownership.
  • Compare delivery options using business outcomes, review effort, learning and reversibility.
  • Derive boundary and exception tests from an agreed business contract.
  • Explain a critical code path and apply that understanding to a changed requirement.
  • Write a release recommendation with acceptance conditions, named responsibilities and a fallback.

Preparation: 35–45 minutes.
Discussion: 90 minutes.
Optional lab: 60–120 minutes.
Coding prerequisites: basic conditions, loops, dictionaries and tests. A no-code pathway is provided.

Back to contents ↑

2. The case

Monday morning at FieldBridge

At 9:10 on Monday, Asha Rao opened the review request she had created late on Friday. She had joined FieldBridge Software six weeks earlier after graduating. The small services company maintained an internal dashboard for a client that repaired commercial equipment.

Its next opportunity was modest: help a coordinator review a daily ticket export without manually copying each row into a priority sheet.

Meera, the delivery lead, wanted a demonstration on Tuesday afternoon. The client had agreed to watch a prototype and consider a two-week assisted pilot. A useful demonstration could create follow-on work. A misleading one could make the client believe that exceptions had been solved when the team had barely examined them.

Asha’s assignment was a CSV-in, report-out script. It would identify ticket priorities under explicit rules and report rejected rows. It would not send messages, update the ticket system, dispatch technicians or make service commitments.

An approved AI assistant had helped Asha produce an early draft. She asked it to implement the normal path, run two examples and describe the result. On Friday, two open tickets received sensible-looking priorities and a closed ticket disappeared from the proposed queue.

She posted a screenshot. Meera replied that it looked promising.

The question that interrupted the demonstration

Dev, the senior developer reviewing the change, asked what would happen to a normal-impact open ticket exactly sixty minutes old. Asha said she thought it would become P2.

Dev asked her to trace the comparison before running the script. She paused. Then he changed the capitalisation of the status field and asked the same question.

Asha understood variables and loops. But she had accepted several details because the assistant’s explanation sounded coherent. She could describe the script’s intention more confidently than its actual behaviour.

She was also unsure whether asking for time to investigate would be interpreted as a failure to use AI effectively.

Dev did not propose banning the assistant. He wanted to know whether the team had assigned ownership without providing a reliable way to establish it. A screenshot was evidence about those exact inputs. It did not show whether Asha could diagnose the next complaint.

What the coordinator needed

Leela, the client’s coordinator, received exports from several staff members. Some cells contained leading spaces; others used upper-case words. Her main concern was overlooked work, especially a ticket blocking a customer’s operations.

She also wanted a count of records the script could not interpret. Quietly discarding a row could make the queue look cleaner while creating reconciliation work later.

The priority rules were simple: valid open blocked tickets were P1; valid open normal-impact tickets aged sixty minutes or more were P2; other valid open normal-impact tickets were P3.

Repeated identifiers raised another question. Should a later row replace the first one? Leela chose a first-occurrence rule for the exercise, with later records rejected for review. She understood that this might preserve an earlier mistake and require a separate correction process.

The team also agreed that blank age was unknown, not zero. Invalid records had to remain visible in the rejection report. Every input row needed to be accounted for.

Four legitimate concerns

Asha wanted to retain responsibility and develop competence. Dev had only ninety review minutes before another deployment. Meera needed to protect the schedule and client relationship. Leela needed someone who could explain an unexpected result and correct it.

No one had measured the complete assisted workflow. The fictional manual estimate was twenty minutes per daily batch, but it had not been systematically timed. Exporting data, reviewing rejections, reconciling totals and approving actions would still take effort.

The alternatives

At 10:00, Meera asked the team to consider four options:

  1. Keep the demonstration plan, generate more examples with AI assistance and ask Dev to inspect the final file.
  2. Ask Asha to rebuild the script without AI, accepting a narrower demonstration or a delay.
  3. Transfer delivery to Dev while Asha observes.
  4. Keep Asha as the developer, freeze the scope and use the review time for prediction, testing, explanation and a small unfamiliar modification.

More examples could repeat the draft’s blind spots. A manual rebuild could spend the window on syntax. A senior takeover could protect tomorrow’s event while transferring ownership away from Asha. The bounded review could expose important gaps, but ninety minutes might not be enough.

Meera would authorise the demonstration. Dev would recommend whether a pilot was technically supportable. Asha would own the prototype and handover. Leela would control operational use.

By 10:15, Meera wanted a plan stating what would be shown on Tuesday and what would have to wait.

Back to contents ↑

3. Your decision

No outcome is supplied at this stage. The title does not guarantee that Asha passes the review.

  1. What would you authorise: a synthetic demonstration, an assisted pilot or neither?
  2. Which delivery option would you choose, and why?
  3. How would you allocate the ninety senior-review minutes?
  4. What evidence would establish correctness and maintainable ownership?
  5. What would stop the release, and what would the fallback be?
  6. What additional evidence could change your recommendation?

Assignment: Write a 600–900 word decision memo, supported by an option comparison and a one-page verification plan. Cite exhibits, label assumptions and disclose AI assistance. Coding is optional.

4. Exhibit 1: The business contract

These rules are synthetic teaching requirements, not industry-wide service standards.

  • Input consists of CSV-style records with id, status, impact and age_minutes.
  • Trim the ID and preserve its case. Missing or empty IDs are rejected.
  • The first nonempty ID reserves that identifier, including when its row is invalid or closed. Later occurrences of that trimmed, case-sensitive ID are rejected.
  • Trim and lower-case status and impact. Allowed values are open or closed, and blocked or normal.
  • Age must contain only digits 0–9 after trimming. Zero is valid. Blank, negative and fractional values are invalid. Missing or non-string required fields are rejected.
  • Validate closed records too. Exclude only fully valid closed records.
  • For valid open records: blocked means P1; otherwise age greater than or equal to 60 means P2; otherwise P3.
  • Preserve accepted input order and do not mutate the input records.
  • Return accepted records, rejected records with reasons, and an excluded count. Every input row belongs to exactly one category.

Error precedence: missing ID → duplicate ID → invalid fields → invalid age → valid closed exclusion → priority.

Rejection row numbers start at the first data row, excluding the CSV header.

5. Exhibit 2: Synthetic tickets

Eight records for prediction and testing
Row ID Status Impact Age in minutes
1T001openblocked25
2T002opennormal90
3T003closedblocked120
4T004" OPEN ""normal "60
5T005openblockedEmpty cell
6T006opennormal-5
7T007opennormal20
8T001opennormal30

Spaces in row 4 are intentional. Row 5 contains an empty cell, not the words “empty cell”. Row 8 repeats the first identifier.

The original clean demonstration used only rows 1, 2 and 3. Predict the full report before running the draft.

6. Exhibit 3: The draft code

This is a deliberately defective, author-created teaching draft representing an artifact accepted too quickly. It is not a transcript of an actual model response.

def triage(rows):
    accepted = []

    for row in rows:
        if row.get("status") == "open":
            age = int(row.get("age_minutes", "0") or "0")

            priority = (
                "P1" if row.get("impact") == "blocked"
                else ("P2" if age > 60 else "P3")
            )

            accepted.append({
                "id": row["id"],
                "priority": priority
            })

    return {
        "accepted": accepted,
        "rejected": [],
        "excluded": len(rows) - len(accepted)
    }

Investigate before editing

  1. For rows 4, 5, 6 and 8, distinguish the required behaviour from the draft’s actual behaviour.
  2. Test a normal-impact ticket at ages 59, 60 and 61.
  3. Identify which rejected records could be hidden inside the draft’s excluded count.
  4. Explain why changing one comparison operator does not repair the entire contract.
  5. Propose a small counterexample that could disprove your explanation.

Back to contents ↑

7. Exhibit 4: What published evidence contributes

Learning and task completion are different outcomes

Shen and Tamkin studied 52 developers learning an unfamiliar Python library. AI access was randomly assigned. The assisted group showed lower immediate comprehension, without a statistically significant average time advantage. The participants were not a sample of fresh graduates. Findings about interaction patterns were exploratory associations, not randomised comparisons of teaching methods. [S1]

Assistance can also improve measured output

Cui and colleagues combined three workplace experiments involving 4,867 developers. They report more completed tasks with coding assistance and larger gains among less experienced developers. Those output measures do not themselves establish retained learning. [S2]

The learning environment matters

Kazemitabaar and colleagues studied 69 learners aged 10–17 in a structured introductory environment. AI-supported authoring improved, while subsequent manual modification and assessments did not show a general learning penalty. The population and learning conditions differ materially from workplace onboarding. [S3]

Engineering practice and measurement require context

OpenAI’s harness-engineering account describes investment in environments and feedback around agents. It is a company-reported engineering experience, not a controlled learning study or a release policy for this fictional team. [S4]

METR’s February 2026 methodological update explains how selection and time-measurement issues weakened interpretation of its later developer-productivity experiment. [S5]

These sources support investigating several outcomes. They do not establish a universal rule that AI always helps or harms learning.

8. Practice guide and worked analysis

Pause here if using this as an assignment. Complete your recommendation before opening the analysis.

Open the worked analysis

A conditional recommendation

Keep Asha responsible, freeze the scope and run a bounded review of correctness and understanding. Authorise a synthetic, read-only demonstration only if the checks are satisfactory. Treat an assisted pilot as a separate decision.

The pilot needs an operational owner, actual workflow comparison, agreed data handling and a correction process. A successful demonstration does not establish those conditions.

The hidden assumptions

One assumption is that a completed artifact establishes its owner’s competence. Another is that assessing competence requires a full manual rebuild.

A more useful question is: What evidence would let another person trust this developer with the next change?

That moves the review toward prediction, diagnosis, modification and communication. This is our teaching reframing, not a claim that the proposed process is a proven instructional intervention.

Comparing the delivery options
Option Benefit Main limitation
Generate more and inspect Preserves the current workflow. Examples may repeat the original blind spots.
Rebuild without AI Makes independent work visible. May consume time on syntax rather than critical reasoning.
Senior takeover Transfers responsibility to an experienced developer. Uses scarce capacity and may remove the learning opportunity.
Bounded review Examines correctness and understanding while retaining ownership. Needs a clear contract, competent observation and stop rules.

A proposed ninety-minute plan

Minutes Activity Evidence produced
0–15 Agree the contract and predict outputs. Written predictions and identified uncertainties.
15–35 Run the draft and investigate mismatches. Input, expected result, observed result and cause.
35–60 Repair the draft and run contract checks. Corrected behaviour and test results.
60–75 Close AI assistance and attempt a new requirement. Independent prediction, change and explanation.
75–90 Review evidence and record the scope decision. Acceptance conditions, owner, limits and fallback.

These timings are proposals, not measured optimal allocations. If critical behaviour remains unresolved, narrow the demonstration or use the manual fallback.

What Asha must understand

She need not memorise every library call. She should be able to trace the boundary, distinguish invalid from excluded records, explain duplicate handling, diagnose an unexpected result and preserve important behaviour when a requirement changes.

When another decision is defensible

A senior takeover or delay may be appropriate when the deadline cannot be met safely, no competent reviewer is available or the tool would directly change live records. The recommendation depends on the small, synthetic and reversible scope of this case.

Back to contents ↑

9. Hands-on lab

Download the resource pack below. The exercise uses local synthetic data and Python’s standard library. It requires no paid AI account or external API. The supplied reference was tested with Python 3.12.14.

Learner workflow

  1. Predict the report for the eight records.
  2. Run the starter and record mismatches.
  3. Explain each cause before editing.
  4. Repair the implementation while retaining its interface.
  5. Run the checks and add a new contract-derived test.
  6. Complete the independent transfer task before reading the reference.

From the extracted resource directory:

cd lab
python starter.py tickets.csv
python -m unittest -v test_triage

The starter is deliberately wrong, so initial failures are expected. Where appropriate, substitute python3 or py for python.

Reveal the expected full-batch report
Category Expected result
Accepted T001 P1; T002 P2; T004 P2; T007 P3, in that order.
Rejected Row 5: invalid age; row 6: invalid age; row 8: duplicate ID.
Excluded One fully valid closed record: T003.
Reconciliation 4 accepted + 3 rejected + 1 excluded = 8 input records.

What was tested

The reference implementation passed fifteen named contract tests. They cover boundaries, normalisation, malformed and missing values, duplicate IDs, closed-row validation, empty input, accounting, accepted order and input preservation.

The sample CSV and a threshold-change exercise were also checked. Test logs and the reference implementation are in the instructor resources.

These are local exercise results. They do not establish production readiness, workplace savings or learning gains.

10. Independent transfer task

Change the normal-impact escalation threshold from 60 to 45 minutes. Preserve P1 precedence and every validation rule.

  1. Predict outcomes at ages 44, 45 and 46.
  2. Predict the priority of a valid blocked ticket aged 10 minutes.
  3. Identify existing test expectations that must change.
  4. Identify behaviours that must remain unchanged.
  5. Implement or specify the change without AI assistance.
  6. Explain the results using the contract and observed behaviour.

Official documentation may be used for syntax if the assessment permits it. The target is reasoning about the change, not memorising an API.

Reveal the transfer-task check

Normal-impact ages 44, 45 and 46 become P3, P2 and P2. A valid blocked ticket remains P1. A previous expectation that a normal-impact 59-minute ticket is P3 must change under the new threshold.

Stop conditions

Stop the demonstration-ready claim if required priorities are wrong, input accounting fails or the named owner cannot explain a critical exception. Escalate business-rule ambiguity to the coordinator and release ambiguity to the delivery lead.

11. Measuring business value and learning

Measure the work required to obtain a trustworthy result, including export, execution, reconciliation, corrections and review.

Question Useful evidence
Does the tool obey the contract? Tests, representative records and reconciled totals.
Can its owner maintain it? Prediction, diagnosis, novel change and explanation.
Does it help the coordinator? Comparable end-to-end workflow time and error burden.
Is learning retained? A parallel task after a delay, with assistance rules recorded.
What does support cost? Reviewer time, rework, exceptions and escalations.

Net effort benefit per batch = manual end-to-end minutes − assisted end-to-end minutes.

Include setup, training, review and support before claiming a pilot benefit. The case’s twenty-minute manual estimate is unvalidated.

A delayed local assessment can guide mentoring. It is not, by itself, a causal study of AI’s effect on learning. Do not present improvement after repeated practice as proof that the proposed review process caused it.

12. Learning and workplace pathways

Foundation and no-code

Trace four records through the rules on paper. Explain a defect in ordinary language. Submit a decision memo, corrected rule flow and reconciliation.

Practitioner

Repair the starter, add a test and submit a before-and-after report. Include a handover note, actual test results and an independently completed transfer task.

Advanced

Design a stronger correction policy for repeated IDs. Compare first-occurrence rejection with latest-valid-record handling. Specify provenance, audit events, access, recovery and safe updates for a real integration.

Freelancers

Scope a bounded prototype review. Ask the client for approved rules and synthetic examples. Deliver a contract, prototype, tests and handover. Estimate implementation and review separately, and state exclusions, acceptance conditions and future support ownership.

Workforce teams

Apply the same questions to an AI-assisted spreadsheet, report, document workflow or automation: can the owner explain the important decisions, detect exceptions and respond to a changed requirement?

Reusable tutor prompt

I will provide a business rule and my prediction. Ask one question that tests my reasoning. Do not give the answer before I attempt it. Identify unsupported assumptions and suggest a small counterexample.

Reusable review prompt

Compare this draft with the agreed contract. For each possible mismatch, propose an input that would expose it and identify the rule it violates. Separate definite defects from questions for the business owner. Do not invent requirements or successful tests.

Back to contents ↑

13. Instructor teaching note

For assessment use, assign the narrative and exhibits first. Withhold the worked guide and instructor resources until learners submit their predictions and recommendations. Collapsed sections on a public blog are not secure answer protection.

Opening question

Would you authorise tomorrow’s demonstration? What exactly would you be authorising?

Record the answers before discussing code. Separate a synthetic demonstration, an assisted pilot and a live deployment.

Suggested ninety-minute class
Minutes Activity
0–10Opening vote and conditions.
10–25Facts, assumptions and missing evidence.
25–40Trace the draft against the contract.
40–60Compare options and allocate review time.
60–75Challenge recommendations and reveal evidence.
75–90Transfer task and exit recommendation.

Discussion questions

  • What does the client need accomplished?
  • Which uncertainty is technical, organisational or educational?
  • When should a senior developer take over?
  • What evidence would justify a shorter review next time?
  • Could a senior developer pass the same demo while misunderstanding it?
  • What would change if the script updated live records?

Misconceptions to challenge

  • “She did not type it, so she cannot own it.” Ask what maintenance responsibilities she can demonstrate.
  • “Tests passed, so she understands it.” Ask for a fresh prediction and unfamiliar change.
  • “The research proves AI harms every fresher.” Examine the population, task, outcome and limitations.
  • “The demonstration saved twenty minutes.” Ask for a measured baseline and full workflow effort.

A defensible alternative recommendation can earn strong marks. Assess the quality of evidence and reasoning rather than agreement with the worked answer.

14. Assessment rubric

Criterion Weight Strong evidence
Problem and evidence 20% Clear scope, exhibit use and qualified research claims.
Alternatives and judgment 20% Credible options, trade-offs and conditions for changing the decision.
Workflow or technical design 20% Feasible steps, correct contract and named responsibilities.
Verification and failure response 25% Boundary and exception tests, transfer, stop conditions and fallback.
Professional communication 15% Clear recommendation, assumptions, assistance disclosure and handover.

Score each criterion from 1 to 4: 1 = substantially incomplete; 2 = material gaps; 3 = sound and usable; 4 = well supported and explicit about limits.

Weighted score = sum of each weight × score ÷ 4. Set pass requirements according to the teaching context. An aggregate score does not override unresolved critical defects.

15. Research and verification record

The research examined learning, task output, engineering practice and measurement limitations. Primary sources and counterevidence were used to avoid treating one study as a universal workplace rule.

  • Evidence cutoff: 6 November 2026.
  • Research findings are separated from fictional operational details.
  • The reference passed fifteen named local contract tests.
  • The sample report and threshold-change exercise were checked.
  • The proposed mentoring process has not undergone a workplace trial.
  • No external expert review or independent statistical replication was obtained.
  • No production deployment or business saving is claimed.

The research dossier contains annotated sources, a claim register, source cautions and maintenance triggers. Review the case when central evidence is corrected, relevant follow-up research appears, the runtime changes or learners identify a defect.

16. References

  1. Shen, J. H., and Tamkin, A. How AI Impacts Skill Formation. arXiv:2601.20245v2. Read the paper. Companion account: How AI assistance impacts the formation of coding skills , Anthropic, 29 January 2026. Relevant sections: methods, main study, qualitative analysis and discussion.
  2. Cui, Z., Demirer, M., Jaffe, S., Musolff, L., Peng, S., and Salz, T. The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers. Microsoft Research publication record . DOI: 10.1287/mnsc.2025.00535 . Used for the reported task-output finding, not a claim about learning.
  3. Kazemitabaar, M., Chow, J., Ma, C. K. T., Ericson, B. J., Weintrop, D., and Grossman, T. Studying the effect of AI Code Generators on Supporting Novice Learners in Introductory Programming. CHI 2023. Read the paper. DOI: 10.1145/3544548.3580919. Relevant sections: user study, results, discussion and limitations.
  4. Lopopolo, R. Harness engineering: leveraging Codex in an agent-first world. OpenAI, 11 February 2026. Read the engineering account . First-party practice account; not a controlled learning study.
  5. Becker, J., Rush, N., Cunningham, T., Rein, D., and Mahamud, K. We are Changing our Developer Productivity Experiment Design. METR, 24 February 2026. Read the methodological update . Used to qualify generalisations about developer productivity.

Sources accessed 6 November 2026. Third-party publications retain their own rights.

Back to contents ↑

17. Complete case and resource pack

Complete 26-page case: narrative, exhibits, practice guide, instructor notes, assessment and research dossier.

Open the complete Word case

Teaching and practice pack: separate reader materials, instructor documents, worksheets, starter code, tests and reference implementation.

Open the teaching and practice pack

These links open the author’s ChatGPT Library and may require account access. For public distribution, upload the files to your course platform or another public download location and replace these links before publishing.

Reflection

What evidence would make you comfortable asking this person to handle the next change?

Answer that question for your own AI-assisted work: a program, spreadsheet, report, document workflow or automation. Identify one prediction, one failure test and one change you can explain independently.

Friday, November 6, 2026

The Effective AI Engineer #016: The Engineer Who Kept the Decision Open

The Effective AI Engineer · Case 16 of 16

The Engineer Who Kept the Decision Open

Applying Lateral Thinking to Create Meaningful Impact with AI



By Ravindra Dastikop
Thinking method: Six Thinking Hats
Engineering focus: evaluating AI pilots and deciding their next use

A successful pilot earns a decision about its next use, not automatic permission to expand.

An AI pilot can produce convincing demonstrations and useful results while leaving important questions unanswered. The professional task is to establish which uses the evidence supports, which need further work and which should stop.

Research-grounded fiction: The people, organisation and events are illustrative. Six Thinking Hats comes from Edward de Bono; the evaluation and release practices are contemporary engineering applications. The fictional pilot is not a report about the organisations cited.

1. The situation and learning outcomes

A company had completed a pilot of an AI assistant for its customer support team. The assistant retrieved guidance and prepared response drafts. Specialists reviewed each draft before sending it.

The launch presentation showed encouraging results:

  • Drafts appeared quickly.
  • Many specialists found them useful.
  • Routine questions often received suitable responses.
  • Usage had increased during the pilot.

The proposed next step was to expand the assistant across the support department.

Meera, the engineer responsible for evaluation, had helped build the system. She wanted it to succeed. She also knew that the pilot results did not describe one consistent experience.

What you will learn

  • Interpret pilot results within their actual scope.
  • Distinguish useful evidence from unsupported conclusions.
  • Use Six Thinking Hats to structure a review.
  • Generate alternatives to unrestricted expansion.
  • Identify questions that require further testing.
  • Document a decision with ownership and review conditions.

↑ Back to contents

2. The story

A convincing demonstration

At the expansion review, the product manager opened with a demonstration. A routine request arrived. The assistant retrieved the relevant guidance and produced a clear draft.

“This is what we can give every specialist,” he said.

A senior support specialist raised a concern. “For standard requests, yes. For unusual ones, checking the draft sometimes takes longer than writing the response.”

The product manager pointed to the positive feedback. The specialist described a difficult case. Someone mentioned the approaching renewal date for the service contract.

The conversation became a contest between examples.

Meera stopped sharing the dashboard.

“We are discussing evidence, enthusiasm, concern and investment in the same breath,” she said. “Can we examine them separately before deciding?”

Blue Hat: define the decision

Meera proposed a short Six Thinking Hats sequence. Everyone would use the same thinking mode together. Nobody would become the permanent optimist or critic.

She wrote the decision:

Which request categories, users and operating conditions are supported by the pilot evidence?

The options included expansion, limited continuation, redesign, further investigation and stopping a particular use.

The purpose was to reach a decision the evidence could support. Agreement with the original launch proposal was not an acceptance requirement.

White Hat: establish what is known

The team inspected what its dashboard actually measured.

“Response time” meant time until a draft appeared. It did not include the specialist’s review, correction or follow-up work.

The positive feedback came from employees who answered an optional survey. Several participants had not responded.

The pilot had also included many routine requests and relatively few unusual ones.

The existing records were useful, but they did not establish department-wide improvement.

Meera separated three statements:

  1. Routine cases frequently produced usable drafts.
  2. Some specialists reported substantial correction effort.
  3. The total effect on completed work remained insufficiently measured.

The third statement was uncomfortable. It was also more accurate than declaring either success or failure.

Red Hat: acknowledge reactions

Under the Red Hat, participants briefly expressed their feelings without being required to justify them.

The product manager felt proud and impatient to move forward.

A specialist felt relieved when a useful draft appeared, but anxious when a polished response concealed an uncertain interpretation.

Meera felt protective of the work her team had invested.

These reactions mattered to the discussion. They did not become evidence of performance.

Yellow Hat: identify supported value

The team examined where the assistant could help. For routine requests, retrieved guidance and an editable draft could reduce repetitive preparation.

Newer specialists could see useful examples of how to structure a response. The assistant could also make relevant documentation easier to find.

Each benefit was recorded with a condition. A draft was useful when the guidance applied, the response was accurate and review effort remained reasonable.

The team could recognise those benefits while continuing to investigate unresolved categories.

Black Hat: examine reasons for caution

The team examined weaknesses and failure conditions. Unusual requests sometimes required policy interpretation that the assistant handled inconsistently.

Some drafts combined applicable guidance with a plausible but unsupported instruction.

Reviewers could miss such additions, particularly when the rest of the response looked familiar.

Expansion could also change the workload. More users and a different request mix could create conditions the pilot had not exercised.

The specialist who had raised concerns now helped identify categories where the system looked dependable. The product manager helped specify conditions under which expansion would be inappropriate.

Participants were changing thinking activities rather than defending fixed roles.

Green Hat: generate other next steps

The original choice had been framed as expand or do not expand. The team now generated alternatives:

  • Expand only routine categories with adequate evidence.
  • Offer source retrieval without drafting for selected complex cases.
  • Use a structured preparation form where required information was predictable.
  • Keep uncertain categories with the existing specialist workflow.
  • Redesign the review interface to make unsupported additions easier to detect.
  • Stop drafting for categories where correction burden exceeded its value.

Not every idea was selected. The team had nevertheless developed several ways to preserve useful work.

Return to the White Hat: close a critical evidence gap

Discussion could not resolve the missing measurement of total handling effort.

The team arranged a further comparison using representative tasks. Where practical, it assigned comparable work across assisted and existing workflows. It accounted for differences in task difficulty and reviewer experience.

It measured work through completion, including correction and rework. It also checked quality separately. Faster handling could not compensate for failing an essential requirement.

The fictional comparison supported a narrower conclusion than the original launch presentation.

Some routine categories justified limited expansion. Other categories required redesign or more evidence. A small category was removed from AI drafting because its review burden and errors did not support continued use in that form.

Blue Hat: make a bounded decision

At the follow-up review, Meera presented the decision by category.

Each approved use had:

  • A defined scope.
  • Evidence supporting continuation.
  • A responsible owner.
  • Monitoring requirements.
  • Conditions for pausing or changing the use.
  • A review date.

The team retained useful components from the discontinued category, including its test cases and organised source material. Stopping one implementation did not erase the learning.

The product manager looked at the revised plan. “We are expanding less than we expected.”

“We are expanding what we can currently support,” Meera replied.

“And the rest?”

“We have specified what would change the decision.”

↑ Back to contents

3. The thinking method: Six Thinking Hats

Edward de Bono’s Six Thinking Hats separates different thinking activities so that they can receive deliberate attention. [1]

The hats represent temporary modes, not personality types. Participants can examine the same subject through different modes without becoming permanently identified with one position.

Six thinking modes applied to the pilot decision
Hat Thinking activity Application in the case
Blue Organise and direct the thinking Define the decision, sequence the discussion and record the outcome
White Examine information and information needs Inspect measures, missing evidence and limitations of the pilot
Red Express feelings and intuitions Acknowledge pride, anxiety and attachment without treating them as facts
Yellow Explore value and reasons for benefit Identify useful applications and the conditions supporting them
Black Examine difficulties and reasons for caution Identify failure conditions, review burden and limits of expansion
Green Generate alternatives Develop narrower uses, redesigns and different operating arrangements

The sequence used in this case

Blue → White → Red → Yellow → Black → Green → White → Blue

This is one practical arrangement, not a mandatory order. The team returns to the White Hat when it discovers a question requiring additional evidence.

Method distinction: Six Thinking Hats structures the examination. It does not calculate the correct decision, guarantee consensus or replace experiments, specialist judgment and accountable ownership. No PO statement is required in this case.

↑ Back to contents

4. Making the thinking visible

  1. Define the decision precisely.
    Replace “Was the pilot successful?” with a question about particular uses, users and conditions.
  2. Inspect what the measures mean.
    Time to draft and time to completed work answer different questions.
  3. Separate observations from conclusions.
    Positive feedback supports a claim about reported experience. It does not independently establish productivity or quality.
  4. Acknowledge investment and emotion.
    Pride, fatigue and anxiety can be expressed without being disguised as evidence.
  5. Explore benefits and weaknesses deliberately.
    Give each appropriate attention rather than allowing them to cancel each other through argument.
  6. Generate additional options.
    Narrowing, redesigning or changing a function may preserve value.
  7. Obtain evidence the meeting cannot supply.
    A structured conversation cannot fill missing performance data.
  8. Make the decision revisable.
    Record its scope, owner, review conditions and the evidence that could change it.

Reusable prompt

We need to decide the next use of this AI system: [describe it].

Structure the review using Six Thinking Hats. Begin by defining the decision and available options.

Separate recorded facts, missing information, feelings, potential benefits, reasons for caution and alternative designs.

Do not assign permanent hats to participants or invent evidence. Identify which questions require testing outside the meeting.

Finish with a decision record stating supported scope, unresolved limitations, ownership, monitoring and conditions for reconsideration.

Do not force consensus or treat completion of the exercise as proof that deployment is justified.

↑ Back to contents

5. Comparing the next-step options

Possible decisions after an AI pilot
Option When it may be appropriate Evidence or preparation needed
Expand a defined use Quality and operational requirements are met for the proposed scope Representative results, capacity checks and monitoring
Continue a limited pilot Potential value exists, but important uncertainty remains A specific learning question and bounded test
Redesign the interaction The current approach creates avoidable effort or errors A demonstrated problem and comparative testing
Reduce the AI function A narrower capability provides useful support Tests of the remaining function and handovers
Pause a use Requirements are not currently met or necessary evidence is unavailable Clear user communication and an alternative process
Retire an implementation Continued operation is not justified A transition plan preserving necessary work and records

Past expenditure should be recorded accurately. It does not establish the value of future expansion.

A use can also require several changes together. For example, limited expansion may depend on a redesigned review interface and a narrower set of supported categories.

↑ Back to contents

6. Research evidence and limits

Evaluate outcomes as well as execution

Anthropic’s evaluation guidance distinguishes the recorded execution of a run from its final outcome. It also describes combining evaluations with production monitoring, experiments and user research. [2]

These distinctions support examining completed work rather than relying only on a convincing demonstration or the text of a response. They do not establish the performance of the fictional assistant.

Interpret findings within their studied setting

Research reported by Cui and colleagues used randomised field experiments with software developers. The combined analysis found increased completed tasks, while noting noisy individual experiments and differences associated with experience. [3]

These findings illustrate why study conditions, uncertainty and variation matter. They cannot be transferred directly to a customer support assistant or used to justify an unrelated deployment.

The proposition to test

Separating thinking activities and examining evidence at the level of the proposed use can support a more explicit, reviewable decision.

The case illustrates that proposition. It does not establish that Six Thinking Hats improves deployment outcomes, meeting speed or decision accuracy.

Evidence boundary: The pilot observations and comparison results in the story are fictional. The cited sources provide method and engineering context.

↑ Back to contents

7. Practice and evaluation

Accessible exercise

Choose one AI tool or workflow you already use.

  • State the decision you need to make about its future use.
  • Record what you know and what remains unmeasured.
  • Express your immediate reaction separately.
  • Identify benefits and the conditions required for them.
  • Examine difficulties and reasons for caution.
  • Generate alternatives to continuing unchanged.
  • Write what evidence would change your decision.

Technical exercise

Review one AI pilot.

  • Define the unit of analysis: task, user group and operating condition.
  • Inspect sampling, missing feedback and comparison quality.
  • Measure review, correction and rework.
  • Check quality against authoritative requirements.
  • Include failures, exceptions and abandoned tasks.
  • Assess the workload expected after expansion.
  • Use a Six Thinking Hats session to organise the review.
  • Assign tests for unresolved questions.
  • Record a decision for each proposed use.

Evaluation measures

  • Successful completion against requirements.
  • Total handling effort.
  • Correction and rework.
  • Error severity and frequency.
  • Results across relevant task categories.
  • User experience and accessibility.
  • Cost per successfully completed task.
  • Operational capacity and maintenance effort.

Interpret the comparison carefully

Before-and-after differences can reflect changes in workload, staffing or experience. Use a comparison design appropriate to the claim being made and report uncertainty.

Set acceptance requirements before using results to justify expansion. Document any later changes and their reasons.

Do not use an average result to conceal a category that fails an essential requirement. At the same time, avoid drawing confident conclusions from very small subgroups.

↑ Back to contents

8. Professional benefit and transfer

For AI engineers

  • Interpret results within their actual scope.
  • Distinguish model performance from workflow value.
  • Make missing evidence visible.
  • Preserve useful components while redesigning weak implementations.
  • Define conditions for reconsideration.

For technical leaders

  • Avoid turning launch reviews into contests between advocates and critics.
  • Allocate attention to evidence, value, concerns and alternatives.
  • Accept different decisions for different uses.
  • Assign responsibility beyond the demonstration.
  • Treat stopping an unsuitable implementation as a legitimate outcome.

Limits of transfer

A structured discussion cannot guarantee candour, eliminate power differences or repair a poorly designed experiment. Participants need access to relevant evidence and a genuine opportunity to question conclusions.

Some requirements are mandatory. A benefit identified under the Yellow Hat does not cancel a failure to meet them.

Reflection question

What evidence would make you narrow or stop an AI system you helped build?

Professional takeaway

Make the next decision specific, evidence-based and open to revision.

↑ Back to contents

9. Reusable artifact: AI Continuation Decision Record

Complete one record for a defined use. Attach evidence or link to authorised records where appropriate.

  1. System and implementation version.
  2. User group, task and operating conditions.
  3. Decision being considered.
  4. Acceptance requirements.
  5. Evidence sources and comparison method.
  6. Missing information and sampling limitations.
  7. Total handling effort and quality results.
  8. Benefits and their supporting conditions.
  9. Difficulties and failure conditions.
  10. Feelings or intuitions recorded separately.
  11. Alternative implementations considered.
  12. Additional tests and responsible owners.
  13. Decision and permitted scope.
  14. Transition or handover arrangements.
  15. Monitoring and pause conditions.
  16. Review date and evidence that would change the decision.

Completion check: Explain what is supported, what remains uncertain, who owns the next step and when the decision will be reconsidered.

↑ Back to contents

10. Final course application

Select one real AI workflow and prepare a reviewable recommendation for its next use.

  1. Define the purpose.
    State what the person or organisation needs to accomplish.
  2. Examine an established choice.
    Identify its purpose and whether other implementations could serve it.
  3. Generate alternatives.
    Include changes to the workflow, information, interaction and AI role.
  4. Test the complete task.
    Evaluate outcomes, correction effort, exceptions and operational limits.
  5. Investigate failures.
    Separate observations from explanations and seek distinguishing evidence.
  6. Prepare for interruption.
    Establish what continues, waits or stops, and how work recovers.
  7. Review the next decision.
    Use Six Thinking Hats to examine evidence, reactions, value, difficulties and alternatives.
  8. Document the recommendation.
    State scope, ownership, limitations, review conditions and the evidence that could change it.

Final deliverable: An AI Continuation Decision Record supported by task evidence, alternative designs and an explicit account of uncertainty.

The aim is to make a justified next decision. Expansion, redesign, limited continuation and retirement can each be appropriate outcomes.

↑ Back to contents

References

  1. Edward de Bono. Six Thinking Hats. Little, Brown and Company, 1985. Project-supplied source, including the colour functions and discussions of the individual thinking modes.
  2. Anthropic. Demystifying evals for AI agents . 9 January 2026.
  3. Zheyuan Cui, Mert Demirer, Sonia Jaffe, Leon Musolff, Sida Peng and Tobias Salz. The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers . Microsoft Research publication page, June 2025.

Research note: Sources were consulted during preparation of this case on 6 November 2026. Online material can change. The sources do not validate the fictional pilot or establish a measured benefit from the thinking exercise.

↑ Back to contents

By Ravindra Dastikop

Lateral Thinking · Engineering Judgment · Meaningful Impact

AIYING — Accomplishing with AI

↑ Back to top

Accomplish with AI

Powered by Blogger.

Featured post

AI Engineering Hands-On Lab #001 — Build an AI Answer Reliability Test Bench Without Code

AIYING | Daily 24 — Post 009 AI Engineering Hands-On Lab #001 Build an AI Answer Reliability Test Bench — Without Writing Code Lea...

Search This Blog

List of blogs

Search This Blog

About

Translate

Instant Stories

Read in Your Language

Test

share this

ShareThis

Popular Posts