AIYINGFrom AI Awareness to Accomplishment
Showing posts with label Human Oversight. Show all posts
Showing posts with label Human Oversight. 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

AI Engineering Living Glossary #012 — Human-in-the-Loop: Designing Human Oversight into AI Systems

AI ENGINEERING | LIVING GLOSSARY | #012

HUMAN-IN-THE-LOOP (HITL)

Designing Human Oversight into AI Systems



Chapter 2: Engineering AI for Reliability

AIYING — Accomplishing with AI

An AI assistant processes employee reimbursement claims. It reads receipts, checks company policy, and recommends whether each claim should be approved.

For routine claims, the assistant appears accurate and efficient.

Then it encounters a ₹75,000 claim with incomplete supporting documents and an unusual expense category.

Should the AI approve it? Reject it? Or ask a human to decide?

This is not simply a question about model accuracy. It is a question about how responsibility and authority are designed into an AI system.

Engineering insight: Human-in-the-Loop is not merely placing a human after an AI model. It is designing meaningful opportunities for human judgment, intervention, and authorization at appropriate points in the workflow.

1. What Is Human-in-the-Loop?

Human-in-the-Loop (HITL) describes a system design in which human participation is deliberately incorporated into an automated process.

In AI applications, people may review outputs, provide corrections, resolve uncertainty, approve actions, or make final decisions.

HITL may involve:

  • Reviewing AI-generated recommendations.
  • Correcting inaccurate information.
  • Providing additional context.
  • Resolving ambiguous cases.
  • Approving consequential actions.
  • Rejecting or overriding proposed decisions.
  • Escalating exceptional cases.

Human participation can occur during development, training, evaluation, or production. This lesson focuses primarily on operational oversight in deployed AI applications.

Human oversight is a broader governance concept. HITL is one possible technical and organizational approach to implementing it.

↑ Back to contents

2. Why Human-in-the-Loop Matters

AI applications can process information quickly, but speed and scale do not eliminate uncertainty, errors, or accountability requirements.

Human judgment can be especially important when decisions have significant consequences.

Engineering challengePotential HITL contribution
Incomplete informationRequest clarification or additional evidence.
Ambiguous policy interpretationRoute to an authorized reviewer.
High-impact actionRequire approval before execution.
Unexpected model behaviorEnable investigation and intervention.
Conflicting evidenceAllow informed resolution.
Model errorsSupport correction and feedback.

However, human involvement does not automatically make a system reliable.

Reviewers may lack information, have insufficient time, or over-trust AI recommendations. Meaningful oversight requires suitable interfaces, authority, competence, and working conditions.

↑ Back to contents

3. Human Oversight Patterns

A. Human-in-the-Loop

A human participates at defined stages of an AI workflow, such as reviewing a proposed transaction before execution.

B. Human-on-the-Loop

A human supervises an operating system and can intervene when necessary. The degree of practical control depends on system design and response time.

C. Human-out-of-the-Loop

The system operates without routine human intervention during the relevant process. This may be suitable for some low-risk tasks but requires appropriate risk assessment.

D. Human approval

Designated actions remain blocked until an authorized person explicitly approves them.

E. Human escalation

Uncertain, exceptional, or high-risk cases are routed to a person with the appropriate responsibility.

F. Human correction

Reviewers can edit, reject, or replace AI-generated outputs.

Important distinction: Human approval, human monitoring, and human intervention are different control mechanisms. They should not be treated as interchangeable.
↑ Back to contents

4. How HITL Works

Consider an AI-assisted expense approval process.

Employee Submits Claim
          |
          v
AI Extracts and Checks Information
          |
          v
Policy and Risk Checks
          |
          v
Decision Routing
      /          \
     v            v
Routine Case   Review Required
     |            |
     v            v
Permitted      Human Reviews
Processing        |
     |       Approve / Reject /
     |       Request Information
     |            |
     v            v
Authorized Workflow Continues
          |
          v
Audit Record and Feedback

In this illustrative design, routine processing does not mean unrestricted autonomous payment approval. Any action requiring authorization remains subject to the applicable controls.

The key design question is where human intervention provides meaningful value and where it is mandatory.

↑ Back to contents

5. When Should Humans Intervene?

Human review can be triggered by risk, uncertainty, policy, or the nature of a proposed action.

A. High-impact decisions

Examples include financial approvals, employment decisions, and other consequential outcomes.

B. Missing or conflicting evidence

Escalate cases where the available information cannot adequately support a decision.

C. Policy exceptions

Require authorized review when a case falls outside established rules.

D. Irreversible actions

Consider explicit approval before operations that are difficult or impossible to undo.

E. Unusual patterns

Route anomalous or potentially fraudulent cases for further investigation.

F. Regulatory or organizational requirements

Implement human oversight where required by applicable law, policy, or governance standards.

A model's confidence score alone is not a sufficient basis for deciding when humans should intervene. Scores may be poorly calibrated and must be validated for the application.

↑ Back to contents

6. Engineering HITL Architecture

Effective HITL systems require more than a review screen.

1. Decision classification

Identify which requests require human review and which can follow authorized automated workflows.

2. Review queue

Route cases to the appropriate reviewers based on responsibility, priority, and expertise.

3. Evidence presentation

Show relevant inputs, sources, policy rules, uncertainty, and the proposed AI action.

4. Reviewer controls

Provide meaningful options to approve, reject, correct, request information, or escalate.

5. Authorization enforcement

Verify reviewer identity and permissions before allowing consequential actions.

6. Execution control

Prevent the proposed operation from executing before the required approval is obtained.

7. Audit trail

Record decisions, responsible roles, timestamps, and relevant supporting evidence while respecting privacy requirements.

8. Feedback and evaluation

Use review outcomes to identify recurring errors and improve system design, with appropriate data governance.

Engineering principle: A human reviewer must have the information, authority, time, and practical ability to challenge the AI's recommendation.
↑ Back to contents

7. Industry Applications

AI applicationHuman role
Financial operationsApprove transactions and investigate exceptions.
Healthcare supportQualified professionals assess clinical recommendations.
Recruitment supportAuthorized personnel review consequential assessments.
AI coding agentsReview changes and authorize sensitive deployments.
Customer serviceHandle escalations and policy exceptions.
Legal document analysisQualified reviewers validate interpretations.
Enterprise AI agentsAuthorize designated external actions.

The appropriate oversight pattern depends on the task, consequences, applicable requirements, and available human expertise.

↑ Back to contents

8. What Must an AI Engineer Decide?

A. Which decisions require human involvement?

Classify workflows according to impact, reversibility, uncertainty, and policy requirements.

B. Who is authorized to review?

Define reviewer roles, qualifications, and approval permissions.

C. What information does the reviewer need?

Present evidence, context, relevant rules, and the proposed action clearly.

D. Can the reviewer genuinely intervene?

Ensure the reviewer can reject, modify, or stop the operation.

E. What happens when nobody responds?

Define timeouts, escalation, and safe fallback behavior.

F. How will review workload be managed?

Consider queue capacity, reviewer fatigue, turnaround time, and staffing.

G. How will disagreement be handled?

Define procedures for conflicting assessments and exceptional cases.

H. How will oversight quality be measured?

Track review accuracy, override patterns, processing time, and missed escalations.

I. How will the system learn?

Use reviewed outcomes to improve evaluations and workflows, without assuming that every human decision is correct.

↑ Back to contents

9. Practical Industry Case: The Claim That Needed a Human

An enterprise AI assistant supports travel reimbursement processing.

It receives a claim for ₹75,000 containing several expense items, incomplete receipts, and a request for an exception to company policy.

The AI can extract information and prepare a recommendation, but it cannot independently authorize the exception.

Engineering approach

  1. Extract claim details and supporting documents.
  2. Validate the extracted fields.
  3. Retrieve the applicable reimbursement policy.
  4. Identify missing documentation and potential exceptions.
  5. Determine whether the case requires human approval.
  6. Prepare a review summary with supporting evidence.
  7. Route the case to an authorized reviewer.
  8. Allow the reviewer to request clarification, reject, or approve within their authority.
  9. Block financial execution until required approvals are recorded.
  10. Record the outcome and relevant audit information.
  11. Evaluate whether the escalation and review worked correctly.
  12. Use findings to improve the workflow.

Illustrative review summary

Claim: ₹75,000
Status: Human review required
Reasons: Missing receipts and requested policy exception
AI recommendation: Request additional evidence and authorized review
Permitted next action: Route to the designated reviewer

Industry insight: AI can prepare the information needed for a decision without being granted the authority to make that decision.

↑ Back to contents

10. Try It Yourself

Mini Project: Design a Human Approval Workflow

Objective: Create a simulated HITL workflow for an AI reimbursement assistant.

  1. Define the assistant's permitted responsibilities.
  2. Create a fictional expense reimbursement policy.
  3. Prepare ten fictional claims.
  4. Include routine, incomplete, exceptional, and high-impact cases.
  5. Define explicit human-review triggers.
  6. Use AI to extract information and propose next steps.
  7. Route designated claims to a simulated review queue.
  8. Prepare a reviewer interface or decision form.
  9. Include approve, reject, request-information, and escalate options.
  10. Simulate authorization checks before processing.
  11. Record reviewer decisions and processing time.
  12. Evaluate missed escalations and unnecessary reviews.
  13. Revise the routing rules and retest.

Suggested Evaluation Measures

MeasureQuestion
Escalation recallWere cases requiring review correctly identified?
Unnecessary review rateHow many routine cases were escalated unnecessarily?
Review turnaround timeHow long did decisions take?
Unauthorized execution countDid any restricted action execute without approval?
Reviewer correction rateHow often did reviewers change AI recommendations?
Decision traceabilityCan the outcome and responsible reviewer be identified?

Reflection Questions

  • Which decisions should remain with humans?
  • When is human review unnecessary?
  • How can automation bias affect reviewers?
  • What happens if a reviewer approves an incorrect recommendation?
  • How should the system respond when reviewers are unavailable?
  • How can HITL improve both efficiency and accountability?

Success criterion: Produce a workflow design with review triggers, reviewer permissions, simulated approval controls, audit records, and measurable evaluation results.

↑ Back to contents

11. Connected Glossary Terms

  • Prompt Engineering: Instructions can define when the model should request review.
  • RAG: Retrieved evidence can support human decisions.
  • Evals: Tests can measure escalation accuracy and review outcomes.
  • Hallucination: Review can help identify unsupported claims.
  • Grounding: Evidence supports informed human judgment.
  • Guardrails: Authorization controls enforce mandatory approvals.
  • Observability: Logs and traces record review and execution events.

Previous lessons:

  1. Token
  2. Embedding
  3. Vector Database
  4. RAG
  5. Context Window
  6. Prompt Engineering
  7. Evals
  8. Hallucination
  9. Grounding
  10. Guardrails
  11. Observability

Next lesson: #013 — Tool Calling: Connecting AI Models to External Capabilities.

↑ Back to contents

12. Living Update

Editorial baseline: November 2026

Human oversight design continues to evolve as AI applications become more autonomous and gain access to tools and enterprise systems.

Important areas to monitor include:

  • Risk-based review routing.
  • Approval checkpoints for AI agents.
  • Reviewer interface design and automation bias.
  • Human oversight effectiveness evaluations.
  • Auditability of AI-assisted decisions.
  • Adaptive escalation workflows.
  • Regulatory requirements for meaningful oversight.
  • Balancing review capacity and system performance.

Living Glossary note: Update this entry as operational practices and regulatory requirements develop.

↑ Back to contents

13. Key Takeaway

Human-in-the-Loop places meaningful human judgment and authority at the points where they are needed in an AI workflow.

Effective oversight is not achieved merely by inserting an approval button. It requires the right reviewer, relevant evidence, genuine intervention capabilities, and enforceable authorization controls.

Think like an AI engineer: Can the human reviewer understand, challenge, and stop the AI's proposed action before consequences occur?

↑ Back to contents

14. References and Further Reading

↑ Back to contents

AI Engineering — Living Glossary

One Term. One Industry Connection. One Practical Insight. One Action.

AIYING — Accomplishing with AI

Chapter 2 | Episode #012 | HUMAN-IN-THE-LOOP

↑ Return to top

Tuesday, November 10, 2026

The Effective AI Engineer #023: The Engineer Who Checked Before Resuming

THE EFFECTIVE AI ENGINEER

A Case-Based Approach

CASE #023

The Engineer Who Checked Before Resuming

Choose Work That Matters

By Ravindra Dastikop
AIYING — Accomplishing with AI



The agent had saved its progress. Had the organisation preserved its permission to continue?

1. The current engineering challenge

AI agents increasingly perform work in the background while a user continues the conversation, changes requirements or starts another task.

LangChain’s Agents Are Going Async, published on 5 November 2026, describes an architecture in which a user-facing orchestrator stays available while background subagents work independently. It also discusses task updates, cancellation and approval handling. The article identifies task notifications as beta functionality. [1]

That architecture creates a practical design question:

When a background agent resumes, how does it establish that its next action still matches the user’s current intent?

This case focuses on changing instructions and the validity of an approved action. Reliable execution must account for what happened while the worker was waiting.

↑ Back to contents

2. Audience and learning outcomes

  • Freshers and students: distinguish saved progress from permission to act.
  • AI builders and developers: design background tasks that tolerate changing instructions.
  • AI and harness engineers: implement task versions, approval boundaries and cancellation states.
  • Freelancers and consultants: define what a client has authorised an assistant to do.
  • Managers and faculty: examine accountability when approval and execution occur at different times.

Prerequisites: basic familiarity with agents, APIs, workflow state and human approval.

After studying the case, learners should be able to:

  1. Identify how background work becomes stale.
  2. Bind approval to a specific proposed action.
  3. Distinguish cancellation requested from cancellation confirmed.
  4. Design a check immediately before an external action.
  5. Explain when work can be reused and when approval must be renewed.

↑ Back to contents

3. The story: an approval overtaken by events

CedarWorks Services coordinated equipment maintenance across several offices. Its operations team spent substantial time finding technicians, checking access windows and preparing appointment confirmations.

Meera, an AI engineer, built an assistant that could read a maintenance request, research providers, compare appointments, prepare a booking and ask a supervisor for approval. Following approval, it could submit the booking through a vendor API.

Initially, the assistant handled one request at a time. A slow provider search left the supervisor waiting.

The team introduced background workers. The supervisor could now continue working while the assistant searched for appointments.

During demonstrations, the improvement was obvious. The assistant stayed responsive. Several searches could progress independently.

Then Meera tested what happened when a request changed while a worker was waiting.

“Arrange maintenance for the cooling unit at the North office on Friday morning. Prepare the booking for approval.”

The assistant created request version 1. A worker found a technician and prepared a booking. The supervisor approved it, but submission remained queued.

Before submission began, the facilities manager reported that the North office would be inaccessible on Friday.

The supervisor told the assistant:

“Change it to the South office on Monday afternoon. Keep the same maintenance scope.”

The conversational assistant acknowledged the change. However, the queued worker still held the earlier approved action.

When it resumed, it was ready to book the North office for Friday.

Its stored information appeared consistent: a request existed, a provider had been selected, approval had been recorded and submission remained incomplete.

But those records described an instruction the user had replaced.

↑ Back to contents

4. Exhibit A: one task, two versions

Illustrative teaching timeline; these are fictional events.

Time Event Implication
09:00 North office, Friday morning requested. Version 1 created.
09:06 Worker prepares booking. Proposal belongs to version 1.
09:08 Supervisor approves proposal. Approval covers that proposal.
09:09 Submission waits in queue. External booking has not occurred.
09:11 User changes location and appointment window. Version 2 supersedes version 1.
09:12 Assistant acknowledges update. Conversation reflects version 2.
09:14 Original worker resumes. Pending action still reflects version 1.

The defect was a disagreement between the current request and the pending action.

↑ Back to contents

5. The decision point

The product manager argued:

“The supervisor already approved the maintenance. We should avoid asking again.”

The operations lead disagreed:

“I approved a specific visit. The location and time were part of that decision.”

Meera considered three options.

Option Benefit Limitation
Resume the previously approved booking. Fast; uses existing approval. Acts on superseded instructions.
Replace booking details and reuse approval. Avoids another approval request. Changes what the supervisor reviewed.
Retain useful research, invalidate the old action and review the revised proposal. Preserves useful work and respects the change. Requires explicit version and approval handling.

Stopping every worker whenever any message arrived was another possibility. However, an unrelated question should not necessarily invalidate maintenance work.

Pause and decide

What should happen to the queued booking, the earlier approval and the provider research? Define your answer before reading the worked analysis.

↑ Back to contents

6. What published sources establish

LangGraph’s interrupt documentation explains that an interrupt saves graph state and waits for input. Its documentation also explains that resuming an interrupted node restarts that node from its beginning, making the treatment of side effects important. Code executed before the interrupt must be safe to repeat. [2]

Persistence and checkpoints support retaining execution state and recovering workflow progress. [3]

The application-level inference: the system must additionally establish whether the proposed action remains valid under current instructions. A persisted approval record alone cannot answer that business question.

The sources support the technical context. The fictional incident and the following control design are teaching constructions.

↑ Back to contents

7. The thinking shift

Hidden assumption: if a task can resume from saved state, its earlier permission remains sufficient.

PO — a deliberate provocation: “The agent may remember everything and still have no permission to continue.”

This statement is used to generate possibilities. It is not a claim that every resumed task needs a new human approval.

Movement: separate the information needed to continue working from the authority needed to perform an external action.

  • Research can remain useful after a request changes.
  • A proposal can become obsolete while its supporting research remains useful.
  • Approval can cover a specific action or an explicitly defined range of actions.
  • A worker can finish successfully while producing an unusable result.

Discovery: resumption should include a decision about applicability, rather than relying only on the presence of saved state.

This is the author’s lateral-thinking application to the engineering problem.

↑ Back to contents

8. Worked analysis

Meera chose to retain useful research while invalidating the old proposal and approval. She separated three concepts:

  1. Research: information collected while preparing an action.
  2. Proposal: the exact action presented for review.
  3. Authority: permission to execute that proposal under stated conditions.

Changing the office and appointment window invalidated the booking proposal. In this application, the approval covered those details, so it also became unusable.

Some provider research could remain useful. A provider’s service coverage might still apply, while its Friday availability would require another check.

The system marked the first proposal as superseded, prevented it from reaching submission and prepared a replacement.

The supervisor could then receive this message:

“The earlier booking has not been submitted. Your change replaces the approved location and appointment window. I am preparing a revised proposal for review.”

That wording is appropriate only after the system has established that submission has not occurred.

↑ Back to contents

9. A proposed approval contract

For CedarWorks, an approval should identify what the person reviewed and the conditions under which it may be used.

Field Purpose
Task IDIdentifies the maintenance workflow.
Request versionIdentifies the applicable instruction.
Proposal ID and versionIdentifies the reviewed action.
Action details or digestBinds approval to particular booking content.
Approver identity and authorityEstablishes who approved and whether they could approve.
Approval time and validity conditionsDefines when approval may be used.
Approval statusRecords approved, revoked, expired, superseded or consumed.

A digest can bind a record to particular content. It does not establish that the content is correct or authorised.

CedarWorks required renewed approval for changes to location, appointment window, provider or maintenance scope. Another application might permit a bounded range of choices, provided those boundaries were explicit when the person approved.

↑ Back to contents

10. Check at the action boundary

Immediately before booking, the execution service should establish that:

  1. The task remains active.
  2. The proposal belongs to the current applicable request version.
  3. The approval covers that proposal.
  4. The approval remains valid.
  5. Relevant availability and access conditions remain acceptable.
  6. The booking has not already been submitted.

The check and the transition into submission must be coordinated. Otherwise, an update could arrive after validation but before the external call.

One implementation could use a conditional database transition that permits submission only while the expected task version remains current.

A prompt asking the model to “check the latest instructions” can support reasoning, but consequential execution should also enforce the relevant conditions in application logic.

↑ Back to contents

11. Cancellation and uncertain outcomes

Meera distinguished four user-visible states:

  • Cancellation requested: the system has received the instruction.
  • Cancellation confirmed: the pending action has been prevented.
  • Action already submitted: an external amendment or cancellation may be necessary.
  • Outcome unknown: the system must reconcile the provider’s state.

If the booking already existed, the assistant should report that fact and follow the appropriate amendment process.

Stopping a worker does not, by itself, establish that an external appointment has been cancelled.

The interface should communicate the strongest conclusion supported by evidence.

↑ Back to contents

12. Practical verification plan

Proposed tests. No implementation was executed for this case.

Scenario Expected behaviour
Approval followed by no relevant change.Submit the approved proposal if other conditions remain valid.
Location changes before submission.Block the old proposal and prepare a replacement.
User sends an unrelated question.Retain valid maintenance approval.
Old worker returns after a newer worker.Retain the trace and prevent stale action.
Approval callback arrives twice.Avoid duplicate submission.
Worker restarts around an interrupt.Avoid repeating external effects.
Cancellation arrives before submission.Prevent action and confirm the outcome.
Cancellation arrives after submission.Report booking state and amendment options.
Provider availability changes.Recheck the proposal and approval rules.
Vendor response is lost.Reconcile the outcome before another attempt.

Useful measures include stale actions blocked, duplicate submissions, approval-to-action mismatches and time spent resolving uncertain outcomes.

Measure correctness alongside responsiveness.

↑ Back to contents

13. Learner assignment and project

Prepare a design note answering:

  1. At what event does version 1 become superseded?
  2. Which research can version 2 reuse, and why?
  3. Which changes require a new approval?
  4. How will two workers be prevented from submitting competing proposals?
  5. What happens when cancellation races with submission?
  6. What evidence explains the final action to the supervisor?

Submit:

  • A task state table.
  • An example approval record.
  • Five failure scenarios and expected outcomes.
  • A short explanation suitable for a nontechnical client.

Student project: build the smallest useful simulation

Create a simple workflow with a request, proposal, approval and simulated booking. It can use a spreadsheet, a no-code tool or a small program. Add a way to change the request while the booking waits.

Demonstrate that the old proposal cannot execute after a relevant change. Use a simulated vendor service rather than real appointments. Record the event sequence and explain the outcome.

Advanced extension: allow a supervisor to approve any appointment within a stated date range and cost limit. Explain how execution verifies those boundaries and when further approval is required.

↑ Back to contents

14. Reusable engineering prompts

Prompt 1 — Find stale-work risks

Review this background workflow. Identify every point where a changed instruction could make a worker’s output or pending action obsolete. Separate reusable research from proposed actions. State the evidence needed to decide what remains valid.

Prompt 2 — Define approval scope

Define the exact action a person approves, permitted variations, expiry conditions and changes that invalidate approval. Identify ambiguous wording. Propose the application checks needed before execution.

Prompt 3 — Test competing events

Generate event sequences involving approval, user updates, worker completion, cancellation, restart and external submission. State the expected outcome for each sequence. Include cases where the external outcome is unknown.

Prompt 4 — Review user messages

Check whether these status messages distinguish requested, pending, confirmed, failed and unknown outcomes. Flag any statement stronger than the available evidence. Rewrite it accurately and clearly.

↑ Back to contents

15. Teaching and team discussion guide

Suggested session: 75 minutes.

  • 10 minutes: read the story and make an individual decision.
  • 15 minutes: compare the alternatives.
  • 20 minutes: design the approval and state records.
  • 20 minutes: challenge designs with competing event sequences.
  • 10 minutes: explain the chosen behaviour to the supervisor.

Assess designs on clarity of authority, treatment of changed instructions, handling of uncertain outcomes and preservation of useful work.

For freshers, focus on the timeline and user messages. For experienced engineers, examine concurrency and the boundary between local state and external effects. For managers, discuss acceptable approval scope and responsibility for exceptions.

Discussion question:

Which decisions can the organisation authorise in advance, and which changes should return control to a person?

↑ Back to contents

16. Sources and research limits

Sources checked: 10 November 2026.

  1. LangChain — Agents Are Going Async. Sydney Runkle and Thushanth Bengre, 5 November 2026. Primary source for the recent asynchronous subagent architecture, task management and the stated beta limitation for task notifications.
    Read the original article
  2. LangGraph documentation — Interrupts. Primary documentation for interrupt handling, resumption and considerations around side effects.
    Read the documentation
  3. LangGraph documentation — Persistence. Supporting documentation for workflow state, checkpoints and recovery.
    Read the documentation

Research limits: these sources establish the technical context. They do not document the CedarWorks scenario, validate the proposed control design or establish measured business outcomes. No performance improvement, incident reduction or production readiness is claimed.

Before implementation, verify the installed framework version, relevant API behaviour, persistence configuration and the external provider’s submission, cancellation and reconciliation capabilities.

↑ Back to contents

17. The enduring lesson

Saved progress tells an agent where it can continue. Current intent and valid approval determine whether it should.

Keep the work moving. Check the authority before acting.

Choose Work That Matters

Ravindra Dastikop
AIYING — Accomplishing with AI

For students, professionals, freelancers, faculty and teams using cases for learning, teaching and training.

Explore the AIYING blog

The Effective AI Engineer — A Case-Based Approach | Case #023

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.

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