--:--
Research & Submissions

Tongkuang

Translating situated needs into interaction constraints for dual camera recording

A method for turning recording goals into testable rules for capture, local saving and export in a dual-camera interface.

Read full manuscript ↓

Research question

When a moment cannot be repeated, what evidence should a camera interface have before telling someone that a recording is ready?

Method

Two constructed scenarios, unboxing and a concert, inform a six-field requirement record covering source, situation, goal, behaviour, technical boundary and verification evidence. A finite-state model distinguishes capture, retention and export. Five selected engineering episodes contextualise the model’s assumptions.

Key findings

Reachable states · local goal
10
Reachable states · export goal
14
Injected transition faults detected
4
  • The reference model reached 10 states for the local goal and 14 for the export goal. No violation of the three specified invariants was found within the model.
  • Four deliberately introduced faults exposed early recording feedback, premature completion, false export success and loss of the retained local file.

Limitations

The scenarios are constructed, and the model abstracts away concurrency, timing and later file corruption. The retrospective records do not estimate user preference or deployed reliability.

Full manuscript

Web reading edition of the submitted manuscript, including text, original figures, tables and references.

Abstract

Recording interfaces coordinate capture, local file retention, and destination export, which can finish at different times. This paper develops a six-field requirement record linking source, situation, goal, behavior, technical boundary, and verification evidence. Constructed unboxing and concert scenarios motivate a finite-state specification in which completion depends on the selected local or export goal. Exhaustive exploration finds 10 reachable states for the local goal and 14 for the export goal, with no violations of three stated safety invariants in the reference model. Four deliberate transition faults expose premature recording feedback, premature completion, false export success, and loss of a retained local result. Separately, five retrospective engineering episodes illustrate the limits of background-capture, display-continuity, encoding, and installation evidence. These selected records do not establish reliability, user preference, or the effectiveness of the proposed method. The contribution is a worked connection between situated intent, completion feedback, and acceptance evidence, supported by an executable model and a de-identified record extraction. Future evaluation must distinguish model consistency, implementation conformance, and usefulness in design practice.

Keywords: Scenario based design, Requirements traceability, Interaction design, Dual camera recording, AI assisted development

Introduction

Dual camera recording joins an external event with the recorder’s response, but the interface must coordinate processes that finish at different times. A start request can precede actual capture. Capture can end before a file is finalized. A local recording can survive an unsuccessful export. These distinctions matter when the event cannot be repeated: a completion message becomes a claim that the person can rely on an artifact. This paper examines how the conditions behind that claim can be carried from a recording scenario into an interaction specification.

The research question is how a situated recording goal can be translated into inspectable conditions for starting, retaining, and accessing a clip. The paper develops a six-field requirement record and uses two constructed scenarios to derive behavioral obligations. A finite-state model then checks selected obligations and exposes counterexamples introduced through deliberate changes to the transitions. The contribution is a worked method for keeping completion feedback relative to the intended outcome, including the distinction between local retention and destination export. Five retrospectively selected engineering episodes supply a separate check on the scope of implementation claims; they do not reconstruct the application as a state machine.

Situation and provenance

Scenario based design connects system decisions to activities and circumstances (Carroll, 2000: 43–60). Opening a newly purchased camera, for example, raises questions about preparation time and hand availability that an age-based persona leaves unanswered. A scenario also embeds choices: selecting an emotionally significant purchase already favors a particular account of recording. The requirement record therefore preserves the source of that account. A constructed scenario supports reasoning about consequences; an observed or reported episode can support a claim about someone’s experience. These uses remain distinct even when their written descriptions are equally detailed.

Gotel and Finkelstein (1994: 94–101) locate traceability problems on both sides of a formal specification. A designer may lose the reason for a requirement before coding begins, even if the subsequent implementation is linked perfectly to an issue identifier. The proposed record retains that earlier connection by placing source, situation, and goal alongside behavior and verification evidence. Its purpose is to let a reviewer challenge the premise as well as inspect implementation. Rejection of the premise can remove a feature from the design; it need not be interpreted as a request to improve the same feature.

The Questions, Options, and Criteria approach makes alternatives and their grounds for comparison explicit (MacLean et al., 1991: 201–250). For recording, immediate start, a countdown, and a preparation reminder offer different responses to uncertain timing. Preserving those alternatives helps explain why the current interaction was selected and when it should change. The six-field record incorporates this concern within the behavior and boundary fields. It is a compact adaptation for handoff, rather than a replacement for a complete design-rationale representation.

Goals and completion conditions

Goal-oriented requirements engineering distinguishes objectives, software obligations, and assumptions about the environment (van Lamsweerde, 2001: 249–262). That distinction is useful for recording: opening the package after setup is an environmental condition, whereas withholding a completion indicator until the required evidence exists is a software obligation. Assigning both to a button would make the interface responsible for a condition it cannot enforce. The proposed record identifies which part of the outcome depends on the person, the capture system, or the storage destination.

Damas et al. (2006: 197–207) show how scenarios, goals, and state machines can inform behavior-model synthesis. Their work already establishes that linking these representations is useful for requirements reasoning. The present method uses a manually specified, smaller model rather than an inference algorithm. It concentrates on a design handoff question: which user-visible outcome is being claimed, and which state evidence licenses that claim? The resulting contribution is a situated application and worked specification, not a new synthesis technique or a general replacement for requirements engineering.

AI assisted implementation and the scope of the contribution

Coding assistants make this handoff consequential because they can produce a plausible implementation while unresolved product decisions remain implicit. Vaithilingam et al. (2022: 1–7) document difficulties in using an early code-generation tool, while Barke et al. (2023: 78:1–78:27) distinguish acceleration from exploration in programmers’ interaction with Copilot. These findings motivate a distinction between implementing a settled decision and exploring an open one. In the proposed workflow, an assistant may suggest alternatives, but a change in the meaning of success must return to the requirement record. The cited studies concern earlier tools and do not quantify the reliability of current agents.

The argument concerns design knowledge that can be examined beyond the appearance of an artifact, a concern shared with research through design (Zimmerman et al., 2007: 493–502). Here the contribution is located in the relationship between situated intent, the operational meaning of completion, and the evidence needed to justify feedback. Its evaluation has two layers: the present analysis checks consistency inside an explicit model; later work must establish whether the selected situations and documentation structure are useful in practice.

Method

Materials and analytical boundaries

The study combines conceptual synthesis, constructed scenario analysis, executable exploration of a finite-state specification, and retrospective analysis of engineering records. Jaakkola (2020: 18–26) argues that conceptual work should explain the choice and analytical role of its theoretical resources. Accordingly, scenario design supplies the unit of activity, traceability supplies provenance, design rationale supplies alternatives, and goal-oriented requirements engineering distinguishes an intended outcome from the conditions assumed in its environment. Public Apple documentation constrains the technical example. These sources were selected for their role in the argument, without a systematic literature-review claim. The executable model and its complete output are provided in Supplement S1.

Unboxing and concert recording vary the person’s control over event onset. The recorder can usually delay opening a package; a performance proceeds according to an external schedule. This contrast directs attention to preparation and interruption without assuming that either situation represents a population. Details such as a first camera purchase and a favorite song are constructed analytical premises. They do not constitute participant accounts. The model likewise represents a proposed interaction contract, not extracted application behavior.

Retrospective engineering records

Five episodes were purposively selected from four developer-maintained documents dated 22 September to 8 November 2026, with an accompanying machine-readable codec test report. Selection covered distinct boundaries: background capture, display continuity, output encoding, and installation. The extraction recorded date, configuration, action, reported result, supporting artifact, and unresolved acceptance condition. Both the unsuccessful and experimental background-capture episodes were retained. These are available project records, not a complete test register or a representative sample. Repeat counts and physical-device operating-system versions were unavailable. Supplement S2 supplies the de-identified extraction and source checksums.

The records were inspected retrospectively, without rerunning the device experiments or independently decoding the recordings. The codec JSON was checked against its narrative summary. Simulator names and operating-system labels are reproduced as recorded, without implying commercially available hardware. A project-side playback report lacking a matched date, build, and diagnostic artifact was excluded from the five-episode analysis. Chat excerpts and explicitly simulated feedback were not used as participant data. The constructed scenarios and executable model were developed separately from these records; comparison is interpretive, not evidence that the method caused an improvement.

The six-field requirement record

Each record contains a stable identifier, a version, and six content fields. Source identifies the origin and its evidential status. Situation describes the actor's relevant activity, trigger, and environmental constraints. Goal states the outcome sought without presupposing a particular control. Interaction behavior specifies the visible response and permitted action under stated conditions. Technical boundary identifies capability, permission, resource, and data-handling limits that may prevent the behavior. Verification evidence specifies an observable artifact or action that could support or contradict the requirement. The identifier connects the record to interface states, implementation tasks, and later test records; versioning records when a changed assumption invalidates an earlier decision.

A record distinguishes a proposed requirement, a specified behavior, an executed check, and support from use in context. Each status points to evidence and its scope. A build result establishes that a configuration compiled; playback establishes something about a particular saved clip. Neither establishes why a person would want that clip. For the present analysis, requirements remain scenario-based hypotheses, while the state-exploration results are reproducible computational outputs about the specified model. Keeping those two forms of support separate prevents a model that satisfies its own rules from being mistaken for a validated product.

Separating goal from behavior also changes how alternatives are considered. A portrait overlay is one way to preserve a response; audio commentary or a later reflection may serve a different recording purpose. One record is therefore assigned to a consequential outcome or transition, with related controls referring to it. Decorative details do not require separate records unless they alter that outcome. This scope rule limits documentation effort and makes it possible to withdraw an assumption without losing the rationale for the remaining design.

Walkthrough procedure and acceptance logic

The walkthrough follows five steps. First, state an outcome and mark the source of the proposed situation. Second, list the conditions that must hold before that outcome becomes possible. Third, express the required behavior as states and transitions, identifying what the interface may truthfully report at each stage. Fourth, introduce a counterexample that defeats either the presumed goal or the proposed mechanism. Fifth, name the evidence needed to resolve the uncertainty and the condition under which the requirement should be rejected or revised. Repeating these steps for a contrasting scenario tests the reach of the reasoning without pretending to supply a second empirical case.

Acceptance conditions connect a known situation, a triggering event, and an observable result. Given verified capability and permission, pressing start should acknowledge the request; a recording indicator should depend on confirmation of capture. The implementation must define that confirmation precisely. The present model abstracts it as an input event. Startup delay is a separate quantity that must be measured on the target configuration, so no numerical latency guarantee is assigned here. A requirement can thus be logically specified while still depending on an unresolved measurement or implementation decision.

Conflicts return the analysis to the goal. An enlarged portrait window may preserve expression while obscuring the stage; an immediate exit may interrupt finalization. A provisional choice should identify the outcome it protects and the evidence that could reverse it. This supports revision in both directions: technical constraints can change the interaction, and a different intention can remove the proposed function. Table 1 summarizes the requirements retained for the walkthrough.

Table 1. Specified requirement hypotheses and unresolved evidence

Record and goalProposed behavior and boundaryEvidence still required
R01 Prepare before openingPreserve the first reactionTwo valid previews and explicit capture status; arrangement must allow the object to be opened.Observe preparation and inspect a clip; establish whether recording started before opening.
R02 Frame both viewsRetain event and responseAdjust overlay without obscuring the intended subject; interaction during capture remains a design choice.Compare framing alternatives and record obstruction or unintended input.
R03 Sustain recordingRetain the unfolding eventCheck capability and define interruption behavior; resource limits depend on configuration.Device logs and full clips across promised configurations, including failure cases.
R04 Preserve the outputRetrieve a playable clipSeparate stopping, finalization, and export; report completion only for the outcome confirmed.Inspect playback and retrieval; distinguish local retention from destination export.
R05 Decline self-recordingRespect the immediate intentionConsider single-camera capture or no capture; dual capture is not presumed necessary.Accounts of actual recording choices, including reasons to reject a portrait view.

Finite-state exploration

The executable specification in Supplement S1 represents one recording session as a tuple of phase, selected goal, readiness, capture confirmation, local verification, and export verification. Goal is local or export. Boolean flags summarize evidence already obtained; phase records the interaction state. Each labelled transition is an atomic event. Preflight success establishes readiness, capture confirmation enables recording, and local verification establishes that a playable artifact is retrievable at the selected local location. Destination verification is a separate event. These verification events are assumed truthful by the model; their device-level implementation is outside its state space.

OpenAI Codex assisted with the manuscript structure, parts of the analytical framework, substantial English drafting and revision, reference organization, the executable abstract model, and extraction of the supplied engineering records. The application context and original records were supplied by the author. Constructed scenarios and deliberately introduced model faults are identified as such; no simulated feedback is presented as participant data. AI-generated explanations are not execution evidence. Responsibility for interpretation, verification, and the final submitted text rests with the human author. Tool identification: OpenAI. (2026). Codex [Generative AI tool]. https://openai.com/codex/

The exploration starts once with a local goal and once with an export goal. A breadth-first traversal applies every enabled transition, records new state tuples, and continues until no unvisited state remains. There is no path-depth cutoff. Duplicate start and stop events are represented as self-loops; export retry forms a cycle. The traversal visits each reachable state once, so these cycles do not prevent termination. It checks three state invariants: I1, recording implies readiness and capture confirmation; I2, completion implies local verification and, for an export goal, destination verification; and I3, export failure retains the verified local copy. These are safety conditions. Eventual completion is not claimed, because verification events may never arrive and retries may continue.

Four deliberate transition faults test whether the checks detect the distinctions they are intended to express. M1 reports recording directly on a start request. M2 reports completion directly on stop. M3 reports completion after failed export. M4 discards the local-verification flag when export fails. Each fault is applied independently to the reference transition function. Counts and shortest counterexample traces are computed by the supplied script, not assigned in advance. The faults are diagnostic examples selected from the stated obligations, rather than defects inferred from the project records.

Findings

Unboxing and preparation before the event

Consider a person opening a newly purchased camera who wants the object and the immediate reaction in the same recording. The response can occur only once in its original context. Recording it therefore depends on completing preparation before opening, making both views available, and knowing when capture has started. This temporal ordering gives R01 a concrete role: it connects a desired artifact to prerequisites that precede the visible event. The design cannot compensate for a late start by changing the composition afterward.

Physical arrangement is part of the requirement. Opening a package can require both hands, whereas a handheld phone occupies one and constrains camera orientation. A stand or another person's assistance is therefore a possible task condition, rather than a fact that the interface can assume away. The design may offer a countdown to create time for positioning, but the countdown does not solve every arrangement. A preview must still allow the person to see whether the object and face are in view. The eventual validation task should examine the recording produced by the whole arrangement, not only whether the start control was successfully tapped.

Three counterexamples delimit the proposal. Once the package is open, preparation cannot recover the original response. If the recorder prefers to remain off camera, a mandatory portrait view obstructs the task. If the object is the primary subject, enlarging the portrait can reduce the useful detail. Single-camera recording and alternative framing should therefore remain available for evaluation. They are alternatives to the mechanism, not defects in the person’s supposed willingness to use dual capture.

Concert recording and externally controlled timing

In the second constructed situation, a person wants to record a stage event together with their reaction. The start of a favorite song and its duration are not under the recorder's control. Preparation may be possible, but repeated adjustment during capture competes with attention to the event. The provisional interaction priority is therefore understandable status with few required interventions. Overlay placement could be adjusted in preview and remain stable during capture. Allowing movement during recording is an alternative that requires evidence about obstruction and unintended input. Neither choice is treated as universally preferable merely because one produces a cleaner interface.

Apple introduced multi-camera capture in iOS 13 (Apple, 2019). Its current documentation exposes device support, hardware cost, and system-pressure cost through AVCaptureMultiCamSession (Apple, n.d.). These are different questions: an available API does not establish support for the desired configuration or sustained operation under load. R03 consequently requires preflight capability and permission checks and an explicit response to interruption. The abstract model combines capability and permission into one ready flag; checking resource magnitudes remains an implementation task.

Continuity and image quality can conflict during a longer recording. A lower configuration or an early stop may preserve some material, but either changes the outcome the person expects. The selected policy must distinguish an intact dual recording, a partial recording, and a failed attempt. In particular, an interface should not continue to claim successful dual capture after one stream is lost. The specification connects that policy to inspection of the output, while leaving the feasible device-level recovery mechanism open.

A state model that distinguishes requests from outcomes

The interaction separates preflight, preview, starting, recording, and saving. It then distinguishes a verified local result from export and goal completion. A local result is sufficient when the person has selected local retention; an export goal also requires evidence at the destination. Export failure preserves a distinct state with access to the retained local copy. This additional distinction refines the earlier capture-and-saving sequence and makes the outcome of a failed export discussable without treating all captured material as lost.

Table 2 states the obligations at representative transitions. The interface may acknowledge a request immediately while withholding a stronger claim until the relevant event occurs. That distinction permits responsive feedback without equating input with success. A temporary file, a finished capture session, and a retrievable playable clip support different claims. The state exploration below makes the last distinction explicit for local and export goals.

Table 2. Recording transitions and possible disconfirmations

TransitionRequired interaction distinctionPotential disconfirmation
Checking to previewShow the requested supported views or an explicit limitation.A missing stream is presented as valid dual preview.
Preview to startingAcknowledge input while withholding confirmed recording status.An input event alone activates the recording-success state.
Starting to recordingUse implementation-defined confirmation of capture and writing.The interface says recording while the required stream is absent.
Recording to savingHandle repeated stop input and show finalization as unfinished.A second stop request creates conflicting writes or loses the clip.
Saving to local readyVerify the promised local artifact before offering it as retained.Finalization callback is treated as proof of a playable clip.
Local ready to completion or exportComplete a local goal; begin export for a destination goal.The system silently changes the requested destination.
Export to completion or export failureVerify the destination or preserve the local result with an unmet export goal.Export failure is presented as completion, or destroys the retained result.

Consider requirement R04 in more detail. Its source is the assumed need to retain an unrepeatable moment, not a measured frequency of data loss. Its situation begins when capture is stopped. Its goal is an accessible playable clip. Its behavior keeps the interface in saving until the implementation confirms the chosen persistence condition, then provides access to the result. Its boundaries include unavailable storage, interrupted finalization, and permission to export to a destination outside the application. Its evidence includes a recorded transition sequence, inspection of the actual clip, and an attempted retrieval from the stated location. The record is incomplete until the storage destination and confirmation mechanism are selected for an implementation.

Local retention and export should be reported separately. If local verification succeeds but export fails, the result remains available inside the application while the destination goal is unmet. The person may retry export or explicitly choose local retention as the revised goal. The system cannot silently reinterpret the original request to obtain a success state. Repeated stop input should also leave an active finalization operation unchanged. These rules define the interaction contract; they do not prescribe a storage API.

Reachability results and counterexamples

The reference model has 10 reachable states and 12 labelled edges from the local-goal initial state, and 14 states and 17 edges from the export-goal initial state. No reachable state violates I1–I3. Counts are reported separately for the two initial goals; they must not be added as if the graphs were disjoint. A labelled edge includes its event name, so stop and interruption can produce separate edges with the same source and destination. Table 3 reports the export-goal runs, where all four deliberate faults are reachable.

Table 3. Reachability analysis with independently introduced faults

Export-goal modelReachable states / labelled edgesViolating states and predicates
Reference14 / 170
M1 Early recording12 / 141; I1
M2 Early completion15 / 171; I2
M3 False export success12 / 141; I2
M4 Discard retained result16 / 193; I2 and I3

The shortest counterexample to M1 is preflight success followed by pressing start: the interface claims recording while capture confirmation is false. M2 reaches a false completion claim after preflight success, start, capture confirmation, and stop. M3 needs the longer successful prefix through local verification and begin-export before export failure exposes the wrong outcome. M4 first violates retention at export failure; a subsequent retry can also produce completion with no retained local copy. The complete state tuples and event sequences appear in Supplement S1. For a local initial goal, the export-only faults M3 and M4 are unreachable and produce no violations.

This exercise establishes consistency of selected predicates in a small stipulated transition system and demonstrates the diagnostic traces for four stipulated faults. The reference rules were constructed to honor the same obligations that the invariants express; zero violations therefore provide a reproducibility check on that construction, not independent confirmation of its adequacy. In particular, a platform callback incorrectly treated as verification could satisfy the abstract model while the real clip remained unreadable. Implementation assessment must examine the mapping from actual callbacks and file checks to the model’s events.

The counterexamples nevertheless sharpen the design decision. Two interfaces that display the same completion message after stop can have different relationships to the intended artifact. A specification that records only the message cannot reveal the difference. Attaching the message to a goal and an evidence-bearing transition makes the competing behaviors distinguishable before an implementation is accepted. That is the analytical work performed by the record; a reduction in development errors remains a question for comparative evaluation.

What the engineering records support

Table 4 places the five recorded episodes alongside the claims they leave unresolved. E1 and E2 concern cross-application screen-plus-selfie recording, an adjacent workflow with different lifecycle constraints from foreground dual-camera recording. E1 reports background capture failure; E2 reports continued frames and separate save-success flags under an experimental configuration. Neither episode independently establishes that both saved artifacts were retrievable and playable. Their different configurations and unknown repetition counts preclude a controlled comparison or a reliability estimate.

Table 4. Retrospective engineering episodes and limits of inference

Episode and configurationRecorded observationClaim boundary
E1 • 22 Sep 2026iPhone 16 ProBuild 1.1(6)Background camera failure after switching apps: 2 frames, approximately 0.033 s.One documented episode; repeat count and iOS version unknown. No reliability rate.
E2 • 22 Sep 2026iPhone 16 ProExperimental 1.1(8)Camera and preview each 436 background frames over 14.500 s. Original clip 17.634 s; separate save-success flags.Temporary VoIP configuration. No independent playback check or formal-release validation established.
E3 • 28 Oct 2026“iPhone Duo” simulatoriOS 27.138.55 s open-close video: reported expansion black interval 3.412 s; closing black frame approximately 35 ms, then brief home screen.Placeholder background. Display continuity failed; no physical camera acceptance.
E4 • 6 Nov 2026“iPhone 18 Pro” simulatoriOS 27.2Seven synthetic-signal test groups reported passed. Separate rear 10-bit Log and front SDR outputs: 24 frames each, approximately 0.8 s.Codec/output-path checks only. No native dual-camera Log or sustained hardware performance validation.
E5 • 8 Nov 2026iPhone 16 ProiOS unspecifiedConfiguration repair followed by successful installation and launch; logs report multi-camera session running.No photo or recording acceptance performed. Startup does not establish output correctness.

E3 exposes a different gap: restoration of the final screen does not satisfy an uninterrupted-display requirement. Its reported black interval matters even though the application eventually resumes. E4 supports a bounded encoding claim through synthetic signals and seven reported test groups. It cannot establish that a physical camera supplies native Log alongside another camera. E5 supports installation and session startup, while leaving capture and output acceptance untested. These distinctions connect the case material to the model: an observable event must be matched to the particular claim it warrants before being used to trigger success feedback.

The retrospective records do not demonstrate the proposed unboxing or concert scenarios in use. Their contribution is narrower: they show why test reports need to separate configuration, observed output, and remaining obligations. The experimental background-capture workaround is documented as a dependency, not recommended as a release solution. An independent assessment would require version-matched artifacts, repeated runs under specified conditions, and checks against the promised destination and playback behavior.

Handoff to an implementation collaborator

A design handoff should combine visual material with the linked behavior records. Figma documents inspection, code-related information, and asset workflows in Dev Mode (Figma, n.d.). Such material can support implementation but does not specify camera lifecycle, persistence, or exception behavior on its own. SVG is useful for vector assets; a raster image can still serve as visual reference. Neither format guarantees completeness. The relevant question is whether the collaborator receives the states, events, constraints, and unresolved choices needed to interpret the screen. Requiring one export extension would confuse the carrier of visual information with the specification of system behavior.

For R04, a bounded implementation request would identify the current storage strategy, the transitions that may change, the handling of repeated stop input, and the evidence required before showing completion. It would ask the assistant to explain dependencies and mark assumptions that cannot be verified from the available code or documentation. If the assistant proposes a different storage strategy, that proposal should return to design review rather than silently replace the requirement. The output should separate implemented changes, checks actually executed, and checks still requiring a physical device. This structure can be used with a human developer as well; its justification is the handoff problem rather than a claim that AI requires a wholly new design discipline.

Amershi et al. (2019: 1–13) address how AI systems communicate capability, uncertainty, and correction. Applied to development handoff, that concern favors explicit unresolved choices over confident completion language. A generated implementation should identify which checks were executed and which still require a device. A suggested command or plausible explanation is not an execution record. Requirement identifiers make the evidence easier to locate, but reviewing its adequacy remains a human task.

Maintenance is required when a change alters the meaning of an earlier check. Moving a portrait window can change obstruction; revising a completion screen can remove access to a retained clip. A revision should identify the affected requirement, the reason for the change, and the evidence that needs renewal. Earlier evidence remains attached to the version it actually tested. The minimum handoff package consists of relevant screen states, the six-field records, unresolved choices, and references to available evidence. A reviewer can select a visible promise and trace it backward to its source and forward to an acceptance condition.

Withdrawal of a goal differs from implementation failure. A preference to record only an external view challenges the dual-view premise; a failure on an unsupported device challenges feasibility on that configuration. Keeping those judgments separate prevents a successful technical demonstration from certifying user relevance. Data-handling changes require similar attention: introducing remote processing changes the boundary of a local recording flow and calls for a new decision about transfer and retention.

Interpretation and prospective evaluation

The analysis isolates two separable decisions: what the recording is intended to accomplish and what evidence permits the interface to report that outcome. A local clip satisfies one goal but can leave another unfinished. This goal-relative account of completion gives the traceability record a specific analytical purpose. The finite-state exploration tests selected consequences of that account; it does not estimate how often corresponding failures occur in a deployed application.

Field evaluation should start with recent recording episodes described by people who use, reject, or have abandoned comparable tools. Introducing the proposed scenarios only after eliciting those accounts would reduce pressure to confirm the design. The analysis should distinguish remembering, private sharing, and public performance as possible purposes. Preparation that interrupts the event or a preference to remain off camera would count against the present framing. Recruitment, consent, and any applicable ethics review belong to that separate study.

Technical verification should cover the device and configuration range the application actually promises. A test record should identify the build, operating system, camera combination, settings, permission state, interruption conditions, and output destination. Relevant artifacts include transition logs and the resulting recordings, checked for both views, temporal continuity, sound, and retrieval. Duration and acceptance thresholds should be specified before the comparative evaluation rather than selected after seeing favorable runs. Failed finalization and partial recovery deserve explicit cases. This programme addresses whether an implementation meets its specification; it does not establish that the specification describes an activity people value.

Method evaluation needs an equally careful comparison. Providing the proposed records to one group and withholding essential information from another would confound structure with information quantity. A stronger comparison would offer the same scenario and technical facts in both conditions, varying whether the linked record and explicit evidence status are used. Outcomes could include omitted obligations, incorrectly accepted behavior, clarification requests, and documentation effort. Independent assessment should apply a predefined rubric and distinguish a useful clarification from avoidable rework. Developer experience, task complexity, and tool version should be recorded. The protocol should define its primary outcome and sample-size rationale before data collection; this paper reports no such experiment.

A negative result would also be informative. If the linked records increase documentation time without reducing omissions or improving the interpretation of failures, their proposed benefit would not be supported for that setting. If developers obtain the same benefit from a simpler checklist, the six-field structure may be unnecessary. Reporting these possibilities in advance keeps evaluation directed at the value of the method rather than at confirming a preferred representation.

Conclusion

The proposed record links situated intentions to interface feedback through explicit behavioral conditions and evidence. Its central distinction is between capture, verified local retention, and completion of the selected destination goal. In the finite-state example, this distinction permits a retained recording to remain usable after export failure while preventing a misleading completion state. The model and its deliberate faults provide inspectable examples of the obligations that a design handoff must preserve.

The scope remains narrow. Two constructed scenarios motivate the requirements, and the executable model abstracts away concurrency, timing, resource levels, file corruption after verification, and changing permissions. The five retrospective episodes illustrate boundaries in available engineering evidence, without estimating deployed reliability or user preference. Incomplete configuration metadata, developer-selected records, and the lack of independent reruns limit that interpretation. Selective literature and developer-originated framing also limit transfer to other contexts. The next evaluation should challenge both the proposed goals and the cost of maintaining the records, rather than merely demonstrate another successful implementation.

Ethics and data availability

No participants were recruited for this analysis. It examines retrospective engineering records and constructed scenarios; it does not report interviews or a user study. Identifiable chat messages and simulated feedback are excluded. No ethics committee approval or exemption is claimed. A future participant study requires a separate ethics assessment before recruitment. Supplement S1 contains the abstract model and complete computed outputs. Supplement S2 contains a de-identified extraction of five engineering episodes, provenance checksums, and the scope of each claim. The original internal files are not redistributed because they contain project identifiers and unrelated operational information. These extracts enable inspection of the reported analysis, but do not replace the original recordings or independently reproduce the device experiments.

References

Amershi, S., Weld, D., Vorvoreanu, M., Fourney, A., Nushi, B., Collisson, P., Suh, J., Iqbal, S., Bennett, P. N., Inkpen, K., Teevan, J., Kikin-Gil, R., & Horvitz, E. (2019). Guidelines for human-AI interaction. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (pp. 1–13). Association for Computing Machinery. https://doi.org/10.1145/3290605.3300233

Apple. (n.d.). AVCaptureMultiCamSession. Apple Developer Documentation. Retrieved November 10, 2026, from https://developer.apple.com/documentation/avfoundation/avcapturemulticamsession

Apple. (2019). Introducing multi-camera capture for iOS [Video]. Apple Developer. https://developer.apple.com/videos/play/wwdc2019/249/

Barke, S., James, M. B., & Polikarpova, N. (2023). Grounded Copilot: How programmers interact with code-generating models. Proceedings of the ACM on Programming Languages, 7(OOPSLA1), Article 78. https://doi.org/10.1145/3586030

Carroll, J. M. (2000). Five reasons for scenario-based design. Interacting with Computers, 13(1), 43–60. https://doi.org/10.1016/S0953-5438(00)00023-0

Damas, C., Lambeau, B., & van Lamsweerde, A. (2006). Scenarios, goals, and state machines: A win-win partnership for model synthesis. In Proceedings of the 14th ACM SIGSOFT International Symposium on Foundations of Software Engineering (pp. 197–207). Association for Computing Machinery. https://doi.org/10.1145/1181775.1181800

Figma. (n.d.). Guide to Dev Mode in Figma. Retrieved November 10, 2026, from https://help.figma.com/hc/en-us/articles/15023124644247-Guide-to-Dev-Mode-in-Figma

Gotel, O. C. Z., & Finkelstein, A. C. W. (1994). An analysis of the requirements traceability problem. In Proceedings of the First International Conference on Requirements Engineering (pp. 94–101). IEEE. https://doi.org/10.1109/ICRE.1994.292398

Jaakkola, E. (2020). Designing conceptual articles: Four approaches. AMS Review, 10(1–2), 18–26. https://doi.org/10.1007/s13162-020-00161-0

MacLean, A., Young, R. M., Bellotti, V. M. E., & Moran, T. P. (1991). Questions, options, and criteria: Elements of design space analysis. Human–Computer Interaction, 6(3–4), 201–250. https://doi.org/10.1207/s15327051hci0603&4_2

Vaithilingam, P., Zhang, T., & Glassman, E. L. (2022). Expectation vs. experience: Evaluating the usability of code generation tools powered by large language models. In CHI Conference on Human Factors in Computing Systems Extended Abstracts (pp. 1–7). Association for Computing Machinery. https://doi.org/10.1145/3491101.3519665

van Lamsweerde, A. (2001). Goal-oriented requirements engineering: A guided tour. In Proceedings of the Fifth IEEE International Symposium on Requirements Engineering (pp. 249–262). IEEE. https://doi.org/10.1109/ISRE.2001.948567

Zimmerman, J., Forlizzi, J., & Evenson, S. (2007). Research through design as a method for interaction design research in HCI. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (pp. 493–502). Association for Computing Machinery. https://doi.org/10.1145/1240624.1240704