Repository documentation

Eight Hours to Make Coffee

Full Sam / LitAI narrative and animation score. Script draft for review; not yet voiced, rendered or demonstrated. The approved 38-second pilot establishes the cast and animation treatment only. Research and claim limits are in RESEARCH.md; realization requirements are in PRODUCTION.md.

Audience: experienced engineers with working repositories, heterogeneous targets, and a habit of outsourcing their first useful feedback to a distant pipeline. Sam is technically capable, skeptical and increasingly inventive about defending that habit. LitAI is female, quick, dry and willing to puncture his excuses. She wins by showing useful work, not by making every objection foolish.

Performance notation. Each numbered turn specifies exact speech, a phrase cue, speaker action, listener response and audience focus/hold. Times are not guessed: production maps these phrases to the newly recorded dialogue. Where no quoted cue is specified, use the opening spoken phrase for the authored action; an opening hold may already be established before speech. A quiet listening pose is intentional. One focal action at a time; no recurring arm wave, obligatory nod, idle camera drift or synchronized reactions. Reserve a small pause for a punchline, without canned laughter. Project names and code must remain readable.

Visual spine. A shared workbench, the existing-source folder, an “eight hours” card, and Sam's accumulating excuse cards: COFFEE, LAUNDRY, GARAGE, THINKING. These are stage props, not measured execution. LitAI progressively separates the cards from the engineering graph. The graph, native targets and evidence become the story's real activity. The closing coffee can happen beside productive work.

01 — The artisanal feedback loop

Teaching job: Establish the waste and Sam's emotional attachment to it. Evidence: F1, F2. The eight-hour anecdote is fictional dialogue, not a claim about any inspected repository's pipeline.

01.01 · Sam: “I have a proper engineering process. Commit, push, wait eight hours. Plenty of time to make coffee.”

Play: On “proper,” Sam squares a tidy PIPELINE card. On “eight hours,” he puts an 8 HOURS card beside it with misplaced pride. Listen: LitAI studies the card, then looks at Sam. Focus/hold: Read the number; no animated fake stopwatch.

01.02 · LitAI: “Eight hours? Are you making coffee, Sam, or establishing diplomatic relations with the bean?”

Play: She looks once from the card to his small mug, then holds his eyeline. Listen: Sam glances down at the mug. Focus/hold: Mug, then Sam; a short dry pause.

01.03 · Sam: “The pipeline is thorough. Builds. Tests. Platforms. It takes time. You can't rush quality.”

Play: He lays out three legitimate requirement cards rather than waving at the screen. Listen: LitAI gives them her full attention. Focus/hold: Keep these cards: the argument will preserve their rigor.

01.04 · LitAI: “Some work really takes hours. Discovering a missing tool after all that waiting is not thoroughness. It's a very expensive calendar reminder.”

Play: She marks a hypothetical MISSING TOOL note at the entrance to the graph. Listen: Sam stops reaching for the mug. Focus/hold: Early prerequisite failure, labelled “illustration”; no invented terminal result.

01.05 · Sam: “CI is where we find out whether the change works.”

Play: He pushes all three cards toward the distant CI end. Listen: LitAI follows the movement without interrupting. Focus/hold: The empty space before CI.

01.06 · LitAI: “It should not be the first place your change meets a compiler. Let me show you what those eight hours have been concealing.”

Play: She opens a working area before CI and returns BUILD and TEST to it while leaving an independent CI checkpoint in place. Listen: Sam leans his attention toward the workbench. Focus/hold: “Earlier feedback. Required CI stays.”

02 — More than a chat window with a hard hat

Teaching job: Explain what Literate AI actually coordinates. Evidence: F1–F4.

02.01 · Sam: “I've seen AI coding harnesses. They write a function, congratulate themselves, and leave me the integration problem.”

Play: He places a lonely FUNCTION card beside an untidy integration folder. Listen: LitAI acknowledges the problem, hands still. Focus/hold: The gap between one generated function and a verified application.

02.02 · LitAI: “Then keep your skepticism. Literate AI coordinates specifications, target choices, conversion skills, workflow and model routing—and the build, tests and acceptance that follow.”

Play: Reveal five labelled recipe inputs feeding a concrete build/test path; LitAI indicates the relationship once. Listen: Sam reads the labels. Focus/hold: Use five short labels, not a paragraph or a wall of configuration.

02.03 · Sam: “So the specification is a really persuasive README?”

Play: He holds up a README-shaped card as if testing the sales pitch. Listen: LitAI looks at the card, then the acceptance criteria. Focus/hold: Keep the joke small; the criteria become the next focal object.

02.04 · LitAI: “For generated Components, it defines observable behavior. Flavors select target differences. The resolved plan binds the recipe. A motivational README cannot fill in for a failing test.”

Play: Set BEHAVIOR beside a proposed outcome, TARGET beside a selected platform, and PLAN beside their exact resolved inputs. Listen: Sam lowers the README. Focus/hold: The relationship; do not expose irrelevant digest strings in the film.

02.05 · Sam: “And the AI writes its own tests, awards itself a medal, and we all go home?”

Play: He offers a clearly comic paper medal. Listen: LitAI leaves it untouched. Focus/hold: An independent ACCEPTANCE boundary stays visible.

02.06 · LitAI: “No. Generated tests are not permission to grade your own homework. Independent acceptance still has its own contract. Also, your medal appears to be a coffee filter.”

Play: She indicates the independent check, then gives the filter a brief glance. Listen: Sam quietly puts it down. Focus/hold: Acceptance first, punchline second.

02.07 · Sam: “What if I pick a cheaper model and call the output approximately correct?”

Play: He offers a DISCOUNT MODEL card beside the acceptance boundary. Listen: LitAI watches the boundary, not the card. Focus/hold: Requirements do not shrink.

02.08 · LitAI: “Routing chooses eligible models; it does not discount correctness. A weaker model gets the same constraints. You may economize on inference. Please don't economize on what the program is supposed to do.”

Play: Replace the eligible-model card while leaving behavior and acceptance unchanged. Listen: Sam removes “approximately.” Focus/hold: Separate model selection from product authority.

02.09 · Sam: “And the unglamorous parts? Dependencies, packaging, proving the thing I tested is the thing I built?”

Play: He brings those concerns into the recipe rather than leaving them in an unowned integration folder. Listen: LitAI gives them the central panel. Focus/hold: Real lifecycle responsibilities, not a new chatbot portrait.

02.10 · LitAI: “Resolved inputs, dependency evidence, native outputs, tests and independent acceptance belong to the lifecycle. A plan is the recipe. Executed results are evidence. Naming a model is not a software delivery strategy.”

Play: Connect the recipe to the exact built subject and its checks, with execution authorization before host code runs. Listen: Sam traces that chain. Focus/hold: Do not imply a plan itself built, tested or packaged anything.

03 — Keep the repository; retire the superstition

Teaching job: Give an operational starting path without demanding a rewrite. Evidence: F1, F5, B1–B3.

03.01 · Sam: “I already have code. Build scripts. Tests. Years of decisions I can explain, and a few I describe as historical.”

Play: He keeps a protective hand on EXISTING SOURCE. Listen: LitAI looks at the folder rather than reaching to take it. Focus/hold: Ownership, not replacement.

03.02 · LitAI: “Good. Start with the exact release wheel, Python three-eleven or newer, Git, and an authenticated supported coding CLI. Then run doctor. History is welcome. Missing prerequisites are not.”

Play: Show the real release URL and a concise preparation card; give the install commands readable time. Listen: Sam checks the card. Focus/hold: See production for POSIX and Windows activation; do not pretend these commands have been executed.

03.03 · Sam: “And then the ceremonial rewrite?”

Play: He pulls the folder a little closer. Listen: LitAI meets his eyeline. Focus/hold: Hold the protective pose; no erase or replacement animation.

03.04 · LitAI: “No. Inspect an adopt plan. Planning is read-only; applying changes is a separate, acknowledged step. Existing source remains authority until the required conversion and parity evidence say otherwise.”

Play: Present READ-ONLY PREVIEW and a separated APPLY boundary. Listen: Sam relaxes his grip after “existing source.” Focus/hold: The folder's contents stay unchanged. No click, mutation, or fake successful adoption transcript.

03.05 · Sam: “You can work with my tests instead of replacing them with three cheerful assertions?”

Play: He brings his TESTS folder beside the source. Listen: LitAI follows it. Focus/hold: Existing tests enter the development path intact.

03.06 · LitAI: “An admitted retained harness can preserve the original build and test behavior in a disposable copy. Missing stages must remain missing, not turn into a successful no-op wearing a lanyard.”

Play: Match original and wrapper stage cards; leave an absent PACKAGE stage explicitly unavailable. Listen: Sam checks the match. Focus/hold: Transition to BookScan later for the concrete adopted-project example.

04 — A target is not a sticker on a laptop

Teaching job: Establish language/OS variety and honest execution placement. Evidence: F2–F4, F6.

04.01 · Sam: “Fine for one Python project. I have C++, Rust, browser code, Windows users and a FreeBSD machine that judges me.”

Play: He unfolds a heterogeneous target map. Listen: LitAI reads it rather than shrinking it into one default environment. Focus/hold: Real target differences.

04.02 · LitAI: “The current source catalog has Python, C++, Rust, JavaScript, TypeScript, Elixir, Go, Swift and Zig language Flavors, with Linux, macOS, Windows and FreeBSD OS choices. Choose compatible capabilities, not every checkbox.”

Play: Reveal language and OS selectors. Leave unselected combinations neutral. Listen: Sam reaches toward SELECT ALL; she redirects his attention with gaze. Focus/hold: Caption: “Catalog choices ≠ every combination qualified. FreeBSD: development profile; native admission open.”

04.03 · Sam: “I select Windows, run it on this Mac, and announce cross-platform support?”

Play: His Windows sticker hovers above the Mac. Listen: LitAI holds a still, unimpressed look. Focus/hold: The sticker never becomes a passing test badge.

04.04 · LitAI: “That is cross-platform stationery. A target selects the intended platform and recipe. A worker selects where the work actually executes. Those are separate decisions.”

Play: Put TARGET above the recipe and WORKER beside an execution endpoint; return the sticker to the desk. Listen: Sam follows the two paths. Focus/hold: The same clean target/worker diagram persists through the next exchange.

04.05 · Sam: “So I need a new cloud fleet before I get my first useful failure?”

Play: He sketches a large, unnecessary cloud invoice. Listen: LitAI leaves it aside. Focus/hold: Bring the existing local and privately configured workers forward.

04.06 · LitAI: “Start with the capable host you have, then aligned user-supplied workers for the cells it cannot cover. Check tools, model access and capacity first. Private endpoints and credentials stay out of project authority.”

Play: Show host readiness, then selected worker readiness. Any unavailable cell stays visibly held. Listen: Sam puts the invoice away. Focus/hold: No invented worker fleet, automatic VM creation, or claim that every FreeBSD boundary is qualified.

05 — Do the engineering before the pilgrimage

Teaching job: Make pre-CI testing substantial and distinguish evidence classes. Evidence: F1–F4, F6.

05.01 · Sam: “Local checks usually mean lint. My pipeline does the serious work. Meanwhile, I can put a wash on.”

Play: He adds LAUNDRY to the excuse stack. Listen: LitAI looks from it to the empty test path. Focus/hold: One joke beat, then actual testing breadth.

05.02 · LitAI: “Your inner loop needs ambition. Run real unit, integration, build, retained-harness and acceptance checks on appropriate workers. UI, emulator and GPU checks belong where the project requires them.”

Play: Expand the path into those evidence classes. Listen: Sam studies the new branches. Focus/hold: No all-green animation: these are planned checks, not this film's execution transcript.

05.03 · Sam: “All of that is still a lot of work.”

Play: He weighs two substantial stage cards. Listen: LitAI agrees with a steady look. Focus/hold: Preserve the work; the film is not promising to skip it.

05.04 · LitAI: “Yes. Move useful failure detection earlier. Run independent work concurrently when the graph and resources allow. Keep dependencies ordered. Reuse is useful only when its inputs and current validation still match.”

Play: Independent branches advance together; dependent nodes wait. Show cache reuse returning through validation, not bypassing it. Listen: Sam reads the order. Focus/hold: Diagram explicitly labelled “workflow illustration.”

05.05 · Sam: “And a green cache entry means I'm done?”

Play: He offers an OLD PASS card. Listen: LitAI looks at its changed-input marker. Focus/hold: The old card never becomes a current pass.

05.06 · LitAI: “It means you have an old pass. Changed source, targets or dependencies can invalidate it. Evidence needs a subject and scope. A green tick without those is an emoji with tenure.”

Play: Place SOURCE, TARGET and CHECKED RESULT beside the evidence record. Listen: Sam retires OLD PASS to a history tray. Focus/hold: Current evidence, not a decorative receipt or an edited hash.

05.07 · Sam: “My Rust backend and JavaScript frontend agree perfectly in the architecture diagram. Unfortunately, neither has read it.”

Play: He shows a neat arrow between two incompatible result cards. Listen: LitAI opens the actual full-stack sample contract. Focus/hold: Diagram intent versus a checked cross-language boundary.

05.08 · LitAI: “The Rust–JavaScript sample executes that boundary: Rust computes release risk; a trusted runner carries validated JSON to Node's presentation stage. An independent oracle defines the expected dashboard results.”

Play: Show the real two-stage contract and oracle. Listen: Sam follows the JSON across the boundary. Focus/hold: Caption: “Framework conformance sample; not a deployed browser dashboard or a fresh run in this film.”

05.09 · Sam: “So a beautifully formatted but wrong answer still fails?”

Play: He offers the wrong result in an attractive frame. Listen: LitAI looks at the expected values. Focus/hold: Appearance must not substitute for correctness.

05.10 · LitAI: “Yes. Good typography cannot rescue bad arithmetic. Nor can the frontend secretly take over process orchestration. Each role has a contract, and the result must match something besides the generator's self-esteem.”

Play: Keep backend, runner, frontend and oracle responsibilities separate. Listen: Sam removes the decorative frame. Focus/hold: Concrete boundaries, not a claim that every multi-service deployment is automatically orchestrated.

05.11 · Sam: “What about an actual HTTP application rather than a JSON exercise?”

Play: He switches the central target to a packaged HTTP entrypoint. Listen: LitAI follows the requirement change. Focus/hold: Keep the source contract visible.

05.12 · LitAI: “Its verifier can start the packaged process on loopback and check responses, with bounded startup and shutdown. Browser and hardware behavior still need their own checks. No imaginary coverage included.”

Play: Diagram request, expected response and bounded cleanup; no fabricated console output. Listen: Sam studies the separate browser and hardware gates. Focus/hold: The supported verifier handles one packaged HTTP process, not an invented cloud-wide orchestrator. Then return to the waiting excuse.

05.13 · Sam: “What about the wash?”

Play: He tentatively points at LAUNDRY. Listen: LitAI glances at it without moving the technical graph. Focus/hold: A small silent beat.

05.14 · LitAI: “It may continue independently. At last, a workload with an honest dependency graph.”

Play: She parks LAUNDRY outside the software acceptance path. Listen: Sam gives a reluctant half-smile. Focus/hold: Then transition straight to a real project.

06 — BookScan: the book is not Hello World

Teaching job: Show a real retained desktop application and meaningful tests. Evidence: B1–B4.

06.01 · Sam: “Show me something that isn't a greeting service with a very impressive README.”

Play: He closes the toy FUNCTION card. Listen: LitAI brings forward BookScan's project view. Focus/hold: Real repository identity and pinned source citation.

06.02 · LitAI: “BookScan is a Python and PySide6 scanning application. It captures pages, preserves books, supports cropping and reordering, and exports PDFs. Its original source is retained under an adopted pipeline.”

Play: Show a source-backed workflow strip: CAPTURE → EDIT → SAVE → PDF. Listen: Sam looks at the saved-page path. Focus/hold: Use an actual capture when available; otherwise keep this a labelled diagram, not a fabricated app recording.

06.03 · Sam: “A GUI is easy to break. Late camera callbacks. Failed saves. The wrong book exported.”

Play: He identifies those three failure points on the strip. Listen: LitAI lets him finish: this objection is good engineering. Focus/hold: Failure cases, not mug.

06.04 · LitAI: “Its tests cover that: cancellation ignores a late image; failed saves preserve recoverable state; exports respect the selected book and page order. The committed retained receipt records 126 tests.”

Play: Reveal those named tests and the scoped receipt together. Listen: Sam checks the names against his concerns. Focus/hold: Caption: “Recorded repository snapshot; not rerun for this film.” Never imply tests cover every camera or OS.

06.05 · Sam: “And my scanner users have to install an agent?”

Play: He tries to put the development machinery into a scanner user's box. Listen: LitAI gently stops the diagram connection. Focus/hold: Separate app runtime from development tooling.

06.06 · LitAI: “No. They want to scan a book, not adopt your methodology. Literate AI manages development and evidence; the application keeps its own runtime. Your users are allowed to have hobbies too.”

Play: Leave Python/Qt with the app and put the development tools back on the workbench. Listen: Sam accepts the separation. Focus/hold: End on the user's working scan workflow, not the framework logo.

07 — Aviation: a repository with actual baggage

Teaching job: Show retained mixed-language systems and a nontrivial contract. Evidence: A1–A4.

07.01 · Sam: “My repository is a mixed-language monorepo. It won't fit in one of those tidy little project templates.”

Play: He spreads several application folders and shared-package links across the desk. Listen: LitAI studies the dependencies. Focus/hold: The mess has structure.

07.02 · LitAI: “Aviation retains a workspace with Node, Python, Go and Clojure build or test targets. Its adoption contract preserves proven build, test and package behavior. The wrapper does not rewrite the applications.”

Play: Follow root Make targets into the retained workspace. Listen: Sam traces an existing command through the boundary. Focus/hold: Show code, not invented output; annotate that available suites and actual execution scope must be inspected.

07.03 · Sam: “Anything more interesting than a health endpoint?”

Play: He points to a tiny HEALTH card. Listen: LitAI replaces the focal view with the flight-track analyzer's contract. Focus/hold: KML upload → cleaned track → analysis.

07.04 · LitAI: “The analyzer handles KML formats, bounds untrusted uploads, rejects dangerous XML, tracks aircraft identity and reports uncertain units. That's behavior worth specifying before you admire a dashboard.”

Play: Highlight those boundaries on the actual specification. Listen: Sam reads the unit warning. Focus/hold: Label the application “Educational analysis; not approved for flight operations.” Do not animate a fictitious flight approval.

07.05 · Sam: “So the awkward edge cases can run before CI? There goes my scheduled time to alphabetize the spice rack.”

Play: He sets the real TEST card above the pretty dashboard, then reluctantly raises SPICES on “spice rack.” Listen: LitAI holds the new ordering. Focus/hold: Show the committed 273-test retained receipt as a scoped record, not proof that every optional language suite ran.

07.06 · LitAI: “Now you're getting it. Missing suites do not become coverage because the summary has a cheerful color. Your application deserves better evidence than your excuse for alphabetizing the spice rack.”

Play: Add SPICES to the growing excuse stack, then return focus to the recorded suite scope. Listen: Sam looks slightly betrayed by his own housekeeping idea. Focus/hold: The technical qualifier stays readable through the joke.

08 — ElixirSSI: when the language runtime is the system

Teaching job: Demonstrate real image and multi-node emulator verification. Evidence: E1–E4.

08.01 · Sam: “Desktop apps are one thing. What about an operating system built around Elixir and the BEAM?”

Play: He replaces the app box with a small system image and three node slots. Listen: LitAI recognizes the legitimate scale change. Focus/hold: ElixirSSI repository.

08.02 · LitAI: “ElixirSSI uses Elixir for system policy, Linux underneath, and Raspberry Pi five and CM5 targets. Its verifier runs build, test, emulator-device tests and cluster acceptance on three emulated CM5 boards.”

Play: Show the actual four Make stages, then three explicitly EMULATED nodes. Listen: Sam follows the path from image to nodes. Focus/hold: Four stages are not four individual unit tests, and an emulator is not physical hardware.

08.03 · Sam: “And it keeps last week's success around while today's build quietly fails?”

Play: He offers the OLD PASS card from the history tray. Listen: LitAI points him to the verifier's actual source. Focus/hold: Evidence freshness, not opinion.

08.04 · LitAI: “It invalidates the old success before starting. It checks the source and image identities, and refuses to publish a new receipt if the stages fail or the inputs change. Green does not get squatters' rights.”

Play: Retire OLD PASS, run the illustrated stages, and leave the new receipt unfilled until all required conditions are represented. Listen: Sam puts the old card back. Focus/hold: Use a code excerpt or retained scoped report, not a live-run claim.

08.05 · Sam: “Emulated boards still aren't physical boards.”

Play: He keeps a physical-board card separate. Listen: LitAI gives the point its due. Focus/hold: The EMULATED label remains on all three nodes.

08.06 · LitAI: “Correct. The report says physical hardware is unqualified. I enjoy sarcasm, Sam; I do not use it as a hardware abstraction layer.”

Play: She places PHYSICAL: UNQUALIFIED beside the emulator evidence and rests. Listen: Sam accepts this one without a defensive joke. Focus/hold: Let the honest boundary build trust.

09 — LeRTX: the GPU has to be in the room

Teaching job: Explain dependency-bound native acceptance beyond portable tests. Evidence: L1–L4.

09.01 · Sam: “I also have a digital twin, native rendering SDKs and physics. Your laptop is going to wave a green checkbox at the GPU, isn't it?”

Play: He brings in a USD scene, an SDK bundle and a GPU target. Listen: LitAI looks at the target first. Focus/hold: LeRTX, not a generic spinning cube.

09.02 · LitAI: “LeRTX has desktop contracts, pinned rendering and physics inputs, and separate portable and native paths. A Mac's Metal path is not evidence that NVIDIA RTX worked on Linux or Windows.”

Play: Separate the Metal and native NVIDIA paths. Listen: Sam follows the boundary. Focus/hold: Never show a mock viewport as a captured native frame.

09.03 · Sam: “What does a serious check mean there?”

Play: He opens the native acceptance view rather than asking for a larger badge. Listen: LitAI lets the evidence occupy the central panel. Focus/hold: Actual contract items: rendering, pause/camera, reset, editing and save/reopen.

09.04 · LitAI: “One recorded ARM64 admission review runs 160 tests against the admitted application and sealed SDK closure. Other records retain failures and narrower reruns. New source or SDK combinations need fresh qualification.”

Play: Show the specific recorded result and its limitations, with prior failures kept visible in a history lane. Listen: Sam checks the scope. Focus/hold: No stopwatch comparison with eight hours; this is not an end-to-end speed benchmark.

09.05 · Sam: “So I still need appropriate hardware.”

Play: He leaves the GPU requirement attached to the native path. Listen: LitAI meets his eyeline. Focus/hold: Keep the requirement; do not wish it away.

09.06 · LitAI: “Yes. I've organized the engineering, not invented VRAM through positive thinking. Useful portable feedback can arrive earlier; native requirements still need native evidence.”

Play: Portable checks remain useful beside the separate native gate. Listen: Sam puts down the tiny motivational GPU sticker he was considering. Focus/hold: The two evidence classes remain distinct.

10 — Daemonarchy: even the boot story needs receipts

Teaching job: Show retained FreeBSD contracts and refuse adoption overclaiming. Evidence: D1–D4.

10.01 · Sam: “And FreeBSD? Not a Linux container with a daemon sticker. Actual booting, disks, upgrades.”

Play: He lays out a FreeBSD target and disk-layout card. Listen: LitAI takes the storage concern seriously. Focus/hold: Daemonarchy's actual repository and contracts.

10.02 · LitAI: “Daemonarchy adopts existing source in place. Eight contracts separate installation, packages, updates, desktop, diagnostics, compatibility, release and verified boot. It does not claim Literate AI regenerated FreeBSD.”

Play: Reveal those responsibilities around retained source, without a magical code-replacement sweep. Listen: Sam follows installation into updates and boot. Focus/hold: Caption: “Retained contracts; full native lifecycle admission remains open.”

10.03 · Sam: “What would the contracts actually stop me from hand-waving?”

Play: He raises an INSTALLATION COMPLETE card prematurely. Listen: LitAI looks at the still-unchecked completion conditions. Focus/hold: Actual installer contract.

10.04 · LitAI: “Storage intent must be explicit before writes. Completion needs real payload and integrity checks. Boot-environment isolation matters. An animated progress bar is not a successful install. Your dryer also has one.”

Play: Return COMPLETE to a pending state; point once to the concrete requirements. Listen: Sam lowers the card. Focus/hold: No disk-write demonstration or fictitious boot success. Physical graphics and firmware limits remain labelled.

10.05 · Sam: “But a project with open qualification work is not proof that everything is finished.”

Play: He correctly keeps OPEN attached to the native work. Listen: LitAI acknowledges him without a sarcastic gesture. Focus/hold: The open state stays open.

10.06 · LitAI: “It's real engineering, with boundaries you can inspect. A product release, contract adoption and a qualified native lifecycle are three different claims. I refuse to sell you one green blob.”

Play: Separate those three claims with their actual source labels. Listen: Sam starts rearranging his own evidence the same way. Focus/hold: Trust comes from scope; do not present this case as complete native adoption.

11 — CI still gets a vote

Teaching job: Preserve independent CI and release gates while improving feedback. Evidence: F1–F4, F6.

11.01 · Sam: “Then I can delete the pipeline and tell security that a very sarcastic assistant approved everything?”

Play: His hand approaches DELETE CI, stopping before any action. Listen: LitAI looks directly at him. Focus/hold: No deletion or publication occurs.

11.02 · LitAI: “Absolutely not. Required CI, independent review, packaging and release qualification still apply. Pre-CI evidence means you send a better-prepared change—not that my confidence is now your security policy.”

Play: Keep the CI and release gates in place after the pre-CI graph. Listen: Sam withdraws his hand. Focus/hold: Required gates remain required.

11.03 · Sam: “What if a full native build really does take hours?”

Play: He points to a genuinely expensive native stage. Listen: LitAI lets it remain large. Focus/hold: No shrink animation or invented completion time.

11.04 · LitAI: “Then it takes hours. Catch cheap failures before it, run independent work where capacity allows, and preserve the expensive evidence's scope. I offer a shorter feedback path, not an exemption from physics.”

Play: Show earlier failure exits and parallel eligible branches; keep the native stage's honest size. Listen: Sam follows the first useful feedback, not just the last completion. Focus/hold: No guaranteed eight-hours-to-minutes claim.

11.05 · Sam: “But while that pipeline runs, I can clean the garage.”

Play: He adds GARAGE to the now obviously oversized excuse pile. Listen: LitAI looks at it, then at a small unresolved defect. Focus/hold: His priorities do the comedy.

11.06 · LitAI: “Your garage may deserve attention. It should not be the principal beneficiary of your regression strategy.”

Play: She moves GARAGE out of the evidence graph without moving any required check. Listen: Sam notices the unresolved defect. Focus/hold: A short punchline pause, then immediate return to useful work.

12 — Continuous ironing, discontinued

Teaching job: Give Sam agency, a credible changed mind and a concrete next step. Evidence: F1–F6; the examples remain scoped repository research, not fresh demonstration footage.

12.01 · Sam: “The delay gives me time for architectural thinking. Sometimes while vacuuming.”

Play: He adds THINKING to the excuse pile, slightly less confidently. Listen: LitAI glances at the still-open engineering graph. Focus/hold: The pile wobbles once, then settles; no perpetual comic prop loop.

12.02 · LitAI: “Have a life on purpose, Sam. Don't make a slow feedback loop your line manager. With useful results earlier, you can fix the defect while you still remember why you wrote it.”

Play: She puts the actual failure and its relevant source beside Sam. Listen: He recognizes the lost-context problem. Focus/hold: This is a staged example; record a real failure/recovery before filming it as execution evidence.

12.03 · Sam: “Or try another implementation. Check a second target. Turn that odd behavior into an acceptance test instead of a note saying 'investigate later.'”

Play: He, rather than LitAI, adds the next useful experiment and acceptance criterion. Listen: She lets him lead. Focus/hold: Sam has learned a method, not merely conceded a sales argument.

12.04 · LitAI: “Now you're doing software engineering. Your best traditions—clear intent, real tests, independent evidence—were never the problem. The eight-hour interpretive dance around your laundry was.”

Play: She restores the original BUILD, TEST and INDEPENDENT REVIEW cards beside his new plan. Listen: Sam gives an earned, slightly rueful smile. Focus/hold: Respect the discipline; roast the ritual.

12.05 · Sam: “So: choose a real repository, inspect the plan, keep the original source boundary, align the right workers, and earn the evidence before asking CI for its verdict.”

Play: He arranges those steps himself and leaves acknowledgement visibly separate. Listen: LitAI rests her hands. Focus/hold: A concise operational checklist; the source folder remains his.

12.06 · LitAI: “Yes. Start with doctor and a reviewed plan. Then do work your future self can verify. The coffee can run in parallel.”

Play: She puts the mug beside, not inside, the engineering dependency graph. Listen: Sam looks from it to the first real task. Focus/hold: Keep the final commands and release URL readable through the next turn.

12.07 · Sam: “Fine. But I'm keeping the mug.”

Play: He keeps it and returns his other hand to the workbench. Listen: LitAI accepts that without another gesture. Focus/hold: Ownership callback to the source folder.

12.08 · LitAI: “Of course. We preserve valuable legacy assets.”

Play: She looks from the well-used mug to Sam with a small smile. Listen: Sam catches the second meaning. Both settle. Focus/hold: Hold the useful next-step card. End without waving, a fake success badge, or a premature publication claim.