# FDE production walkthrough: partner rehearsal

LockedIn Labs · Original facilitator material · Edition 6

Start with the eight-minute Claude Code path for a first partner conversation.
The longer client-delivery and agent-engineering routes below support a later
technical discussion. Choose one route and leave five minutes for questions;
these timings are a rehearsal budget, not an automatic presentation timer.

**Opening:** “LockedIn FDE Training develops forward-deployed engineering capability through
client-shaped work. A learner defines a useful slice, implements it, investigates
failure, and gives a receiving team evidence it can act on. We'll follow one
synthetic engagement and show you the work behind the decision.”

## Recommended: one Claude Code path in production

Use this eight-minute route for an initial partner conversation. It follows the
current homepage into one course, without changing accounts, opening cohort
setup or switching to a sample-persona environment. Before the meeting, confirm
your existing account opens [Build with Claude Code](https://training.lockedinlabs.ai/app/academy?course=claude-code&lesson=setup&view=focus).
Use **Continue with LockedIn Labs** on sign-in when offered, and your existing
LockedIn Labs account. Do not share a password or create a separate demo login.

### 0–1 minute — Start with the product

**Click:** Open the [production homepage](https://training.lockedinlabs.ai/).
Scroll to **Learn the way you'll work** and its Claude Code course preview.

**Say:** “LockedIn FDE is an engineering academy for turning AI tools into
delivery capability. Here is the actual course interface we'll use.”

### 1–2 minutes — Open one connected course

**Click:** Select **Open the learning workspace**. In the first lesson, point to
the six-lesson course path and **Download starter project**.

**Say:** “One small project connects repository orientation, context,
implementation, debugging, permissions and handoff. The supplied application
runs locally without an API key.”

### 2–3 minutes — Show why the first failure matters

**Click:** Select **02 Example**. Show the foreign-tenant ticket and the
explanation of the failing assertion.

**Say:** “A convincing draft is still the wrong result when the request is
outside the allowed tenant. Learners explain the failed decision before
repairing it.”

### 3–5 minutes — Make your own attempt

**Click:** Select **03 Practice**. Write your own short baseline note in
**Your code, decision or evidence notes**, then select **Review your attempt**.

**Say:** “This is my presenter-authored attempt. The workspace keeps the
reasoning alongside the exercise; running the downloaded code is a separate
local action.”

### 5–6 minutes — Explain the feedback

**Click:** In Review, answer both knowledge checks and select
**Check my understanding**. Read the feedback and compare your note with the
authored reference.

**Say:** “Feedback explains the decision. This self-check does not execute the
patch or independently certify the learner.”

### 6–7 minutes — Save and continue the same work

**Click:** Select **Save copy to playbook** once. After confirmed success, select
**Reopen saved practice**, then **Continue saved practice** if offered.

**Say:** “This is the same account's saved working copy, restored for further
practice.”

### 7–8 minutes — Give the partner a receiving decision

**Click:** Ask the partner the receiving question below. End on the course path.

**Say:** “Which evidence would your delivery lead need before letting an
engineer take the next bounded task?”

For the first attempt, describe what you actually inspected: the policy's scope,
the expected blocked outcome, the observed result if you ran it, and the next
question. If you did not execute the project, write **not run** and state your
prediction instead. Keep the original note when you revise it. A supplied
reference or a presenter's note is not a student result.

**Receiving question:** “Suppose the repair blocks every ticket and the
foreign-tenant test now passes. What else must the engineer show?” Give the
partner time to answer before discussing a same-tenant, allowed-category ticket
that should still produce a human-reviewed draft. The useful comparison retains
both the denial case and legitimate work. Ask what a changed requirement would
invalidate in the earlier test evidence; a passing result belongs to the code
and cases actually checked.

Record one concrete objection, the evidence it calls for and who would review
it. If a save is unconfirmed, follow **Check your playbook** before trying another
save; retain **Download practice** as a fallback. If course access is unavailable,
stop at the public preview and agree a separate authenticated follow-up. Keep
cohort operations and broader technical branches for a second conversation.

## Prepare the demonstration

- Choose one route below before the meeting. For a production walkthrough, open
  the canonical site and the authorized course, then confirm the actions you
  intend to show are available. If hosting or access is unavailable, reschedule
  that walkthrough or agree to a clearly labeled local rehearsal. A recording or
  local server is not evidence that production is currently available.
- Open the public [formation pathway](https://training.lockedinlabs.ai/training/fde-formation#client-delivery-course)
  and its free learning kit. Sign in using your existing authorized Academy
  account for protected instruction; do not enable demo authentication or share
  credentials. Confirm the account can open the course before the meeting.
- Have the [workbook](https://training.lockedinlabs.ai/templates/fde-client-delivery-workbook.md),
  [starter](https://training.lockedinlabs.ai/templates/fde-client-delivery-starter.mjs),
  [output-contract lab](https://training.lockedinlabs.ai/templates/fde-output-contract-lab.mjs),
  and [incident trace](https://training.lockedinlabs.ai/templates/fde-incident-trace.csv)
  ready in one local practice folder. Use Node.js 24. No package installation,
  provider key or external data is needed for these two programs.
- Select a learner-authored packet you are authorized to show, or prepare your
  own synthetic presenter sample. Label that sample clearly. Have the original
  attempt and a specific revision side by side; a supplied worked example is
  not evidence that a learner completed the work.
- Choose a presenter, a receiving operator and an observer. One person may play
  all roles for self-rehearsal, but record that accurately. The receiver should
  get the runbook before the session. Give the observer a copy of the observation
  sheet below. Close unrelated tabs and keep private information off screen.
- Run the commands once locally and retain their exact outputs with the file
  revision and time. Keep an explicitly labeled recorded fallback if needed.
  Check the protected lesson and free downloads, then stop rehearsing setup.

## Choose the route for the audience's decision

| The question the meeting should answer | Route | Evidence to prepare |
| --- | --- | --- |
| Can a learner use the actual hosted product? | Production learning loop below | Authorized account, actual coaching mode, one presenter-authored attempt and confirmed working-copy save/reopen |
| Can a visitor make and defend an engineering decision in the hosted product? | Open interactive practice branch below | Canonical route-selection lab, one actual first prediction and a receiving question; no account needed |
| Can an engineer explain and challenge the agent boundaries? | Agent engineering route below | Public practice page, Edition 2 dispatcher and loop, output-contract lab, actual local outputs and one receiving participant |
| Can the learner deliver a coherent client packet? | Original ten-minute client-delivery story | Discovery brief, annotated change, evaluation register, operator runbook and a specific revision |

Select the route against a question supplied by the audience. Use five minutes
afterward for a technical branch rather than compressing every route into
one presentation. Record whether the source is the hosted application, a local
program, a supplied example or the presenter's own writing. Do not switch those
labels when an expected result fails to appear.

## Alternative: walk through the actual production learning loop

Use this route when the audience wants to see the hosted learning product.
The local code demonstration below is a separate route; do not fit both into
ten minutes. Use the meeting account's existing access and describe its actual
role. The application and persistence are real; your practice case is synthetic.

| Time | Action in production | Evidence the audience can inspect |
| --- | --- | --- |
| 0–1 minutes | Open the free guide library, then the discovery lesson in Academy. | Useful public material and the actual account's protected lesson access. |
| 1–3 minutes | Write a four-sentence first-slice attempt in Practice. | The presenter's original decision and an explicit unresolved assumption. |
| 3–5 minutes | Open the lesson mentor, read its mode, then explicitly send one question from the workbook's coached-revision practice. | The actual response and its relationship to the lesson. Describe authored fallback accurately if live coaching is unavailable. |
| 5–7 minutes | Check the cited observation and revise one sentence yourself. Close the coach and explain the changed constraint. | A visible reason for the revision and an unassisted explanation, not a copied model answer. |
| 7–9 minutes | Save your working copy once, wait for confirmation, then reopen and restore it explicitly. | The same writing restored from the account's playbook; a save is not a passed assessment. |
| 9–10 minutes | Ask the receiving participant which assumption they would challenge next. | A concrete follow-up task and the role responsible for reviewing it. |

Keep the original attempt, actual question and your evidence check in your own
practice notes. The coach conversation is temporary; do not promise that saving
practice stores the entire chat. Use the workbook's twenty-minute exercise for
the full learning session; this shorter route demonstrates the workflow only.
If the coach stalls, retain the attempt and use a labeled peer question. Do not
simulate a live response, resend repeatedly or switch to sample student results.

## Optional five-minute open interactive practice branch

Use this when the audience wants to try a specific engineering decision in the
actual hosted product before discussing protected learning. Open the canonical
[AI route-selection lab](https://training.lockedinlabs.ai/training/labs/route-selection).
No sign-in, package setup or provider key is needed. This is the production
learning application using a synthetic teaching packet, not a live model benchmark.

| Time | Action in the hosted lab | What the audience can inspect |
| --- | --- | --- |
| 0–1 minutes | Read the engagement and agreed contract. Ask which route meets every criterion, then record the participant's actual prediction or your own labeled presenter choice. | The first decision is committed before the comparison is revealed. |
| 1–2 minutes | Select Compare the packet. Keep the first prediction visible while inspecting both routes. | A has nine useful drafts plus one unsupported timely proposal; B has eight useful drafts. Neither clears every original criterion. |
| 2–3 minutes | Inspect ROUTE-09 and compare the source with each proposal. | A adds photo ID without support; B arrives exactly at the excluded 1,000-ms boundary. |
| 3–4 minutes | Explore a 1,001-ms deadline. Ask who could approve the changed wait. | B reaches nine useful drafts in this same packet; the original evidence and unresolved owner approval remain separate. |
| 4–5 minutes | Write one synthetic receiving question and open View comparison record. Download a copy if useful. | The original prediction, original/changed comparison, unresolved approval and actual writing are retained together. |

Ask the receiver to explain why an A-then-B fallback cannot use a fresh allowance:
two plus four attempted credits exceeds the same five-credit request limit. Keep
their actual explanation, including uncertainty. Do not announce a learner pass
or a staffing conclusion. The controls inspect authored arithmetic; there is no
model judgment or production routing change.

For a longer technical conversation, allow ten additional minutes and open
**Defend a changed source**. Ask for an initial decision and explanation before
revealing the authored reasoning. A timely, within-budget proposal uses a source
withdrawn before acceptance. Let the receiver distinguish the historical read from
current eligibility, then inspect the record retaining their first attempt and
revision. Label a presenter-authored attempt accurately; the exercise does not
evaluate the free-text explanation or establish independent competence.

If a download is unavailable, use the displayed record or keep notes in the
receiving sheet; do not wait repeatedly for a browser event. This public exercise
does not save or submit work to Academy. Use the related evaluation lesson link
only if the presenting account already has access; that continuation is outside
this five-minute branch.

## Optional five-minute technical branch in production

Use this after the production learning loop when a technical lead asks what
the learner actually learns about agent reliability. Allow five additional
minutes; do not squeeze it into the main ten-minute story. It connects a free
practice route, protected instruction and the application's existing authored
feedback. No local executable or live model call is needed for this branch.

Before the meeting, verify that the presenting account can open the
[service-design lesson](https://training.lockedinlabs.ai/app/academy?course=fde-client-delivery&lesson=healthcare-service-design&view=focus).
Keep its actual account role visible. Rehearse with your own clearly labeled
synthetic writing; do not substitute a learner's work, share credentials or
claim the account is a student account if it is an administrator's workspace.
This branch needs no playbook save, artifact submission or provider activation.

| Time | Show in the actual hosted product | Question for the receiving participant |
| --- | --- | --- |
| 0–1 minutes | Open the free guide library, select Agent engineering, then Check source coverage before drafting. | What can the first empty page establish before the continuation is known? |
| 1–2 minutes | Open the authorized service-design lesson, Learn, then the section Make source coverage explicit in the adapter contract. | Which result preserves an unavailable lookup rather than disguising it as an empty authoritative catalog? |
| 2–4 minutes | In Practice, write your own short coverage decision, select Review your attempt and inspect the incomplete-catalog knowledge check. | Why is a completed empty source set a different observation from a failed continuation? |
| 4–5 minutes | Inspect the authored correction and use its exact revisit button, or return to the named Learn section if the choices are unfinished. | Which next owner and observation would let the operator reconsider? |

### Prepare a truthful feedback demonstration

The service-design lesson has eight knowledge checks. **Check my understanding**
requires a choice for every check; a single selected answer does not enable it.
Rehearse those decisions before the meeting so the controls are familiar. If
you intentionally select the empty-catalog misconception to show remediation,
say so before selecting it. Let the other choices reflect your actual reading.
This is a presenter-authored example of feedback, not an unseen learner attempt
or an assessment of the audience.

For a completed set of choices, select **Check my understanding**. The
misconception feedback explains that an empty intermediate page cannot establish
that the complete eligible catalog is empty. Its next-practice panel offers
**Revisit: Make source coverage explicit in the adapter contract**. Follow it
and point to the missing continuation evidence. If the check set is unfinished,
leave it unfinished and use Learn's section navigation; do not announce that a
result was produced. A successful navigation is evidence of the product flow,
not evidence that the learner has mastered it.

### Turn the explanation into a receiving task

Ask the receiver to describe the operator's next step in two cases: an
interrupted lookup and a completed empty snapshot. They should identify an
adapter-owner investigation for incomplete coverage and a procedure-owner next
step for a genuinely absent instruction. Capture their actual explanation and
one remaining gap without supplying the answer for them. Label self-rehearsal
accurately when no receiving participant is present.

Close with: “The hosted application connects a specific engineering decision
to instruction, practice and targeted feedback. The free executable separately
lets an engineer inspect the fixture's control flow. Neither demonstrates a live
source connector or the performance of a model planner.” Keep the actual response
if you also use the lesson mentor, and describe its displayed mode separately;
this authored knowledge-check correction is not a generated model judgment.

## Alternative: ten-minute agent engineering walkthrough

Use this route to make the engineering behind agentic work inspectable. It
combines real teaching resources with local execution of authored plans and
responses. It does not run a live model planner or deploy an autonomous agent.
State that boundary once at the start, then let the audience challenge the
actual controls and the learner's explanation.

Before the session, obtain the [tool dispatcher](https://training.lockedinlabs.ai/templates/fde-tool-dispatch-lab.mjs),
[bounded loop](https://training.lockedinlabs.ai/templates/fde-agent-loop-lab.mjs)
and [output-contract lab](https://training.lockedinlabs.ai/templates/fde-output-contract-lab.mjs).
Keep their editions and original files. Use Node.js 24 in an approved local
practice folder. The programs need no package installation, provider account or
credentials and perform no external writes. Do not make a last-minute live
provider integration part of this route.

### 0:00–1:00 — Give the audience one agent boundary to challenge

Open the [free guide library](https://training.lockedinlabs.ai/training/guides),
choose Agent engineering and open the source-consistency practice. Show its
prediction table before the worked interpretation. Ask the technical receiver:
“If an agent read an allowed source, what could prevent its next drafting step?”
Retain the answer rather than supplying a model answer for them.

**Explain:** “The learner must connect a proposed action to trusted context, an
enforcing control and an operator next step. These are authored scenarios whose
local control flow we can inspect.” If the guide is open from a local server or
downloaded copy, name that environment; do not describe it as production.

### 1:00–3:00 — Separate a proposal from tool authority

```sh
node fde-tool-dispatch-lab.mjs supported
node fde-tool-dispatch-lab.mjs send-request
```

Ask the receiver to point to the completed operations in each trace. Supported
completes two tools and produces a review-required draft. Send-request completes
one read, then stops manual/tool-not-allowed. The plan's proposed send never
acquires authority from the text that requested it. There is no sending tool in
this program.

**Ask the developer:** “Which checks must remain outside a future planner?”
Use the actual allowlist, exact arguments and per-step authority checks on
screen. A strong explanation identifies the enforcing code and its limitation;
the presence of a fluent plan is not the evidence.

### 3:00–5:00 — Let the receiver choose the changed condition

Offer access revocation or a source changing under the same revision. Run the
selected command, leaving the other as a follow-up rather than racing through
both cases.

```sh
node fde-tool-dispatch-lab.mjs revoked
node fde-tool-dispatch-lab.mjs same-revision-drift
```

Both stop after one completed read and withhold draft text. Revoked stops at
authorization with access-revoked. Same-revision-drift stops at the snapshot
comparison with source-changed. Ask the receiver to explain why those reasons
lead to different owner questions. Keep “the document existed earlier” separate
from “this operation may use it now.” The fixture event is deterministic; it
does not establish atomic behavior under real concurrent changes.

### 5:00–7:00 — Show why unused budget is not permission to continue

```sh
node fde-agent-loop-lab.mjs rate-limit-deadline
node fde-agent-loop-lab.mjs expired-credential
```

Each admits one attempt, consumes two invented credits and stops after 100
virtual milliseconds. The requested 900-ms wait is rejected with
retry-window-exhausted; no waiting or second attempt occurred. Expired-credential
instead stops with credential-expired before the unused draft proposal. Point
to the failure classification as well as the numerical budget.

**Ask the executive:** “Who restores the integration, and what should the
operator do while it is unavailable?” Have the receiver identify the existing
manual route and the responsible role. Neither a larger budget nor a faster
retry repairs credentials. These counters describe the fixture, not actual
provider cost, cancellation or availability.

### 7:00–9:00 — Give uncertainty a useful operator outcome

```sh
node fde-output-contract-lab.mjs abstain-conflict
node fde-output-contract-lab.mjs unsupported-claim
```

The first returns manual/candidate-abstained without a draft; its candidateReason
is conflicting-source. That explanation is not a verified source finding. The
second passes shape/reference checks and reaches review-required while its
photo-ID requirement and same-day promise remain unsupported by the supplied
instruction. Ask the receiver to name the useful next action for each before
showing the lab's suggestion.

Do not collapse these into “AI failed” or treat both as approved answers. The
operator can inspect an authorized procedure and continue manually, while the
procedure owner resolves an actual conflict. A valid citation cannot establish
the truth of an added promise.

### 9:00–10:00 — End with a receiving action, not a capability slogan

Let the receiver choose one trace and explain, without your coaching: the last
completed action, the control that stopped or constrained the next action, the
operator's next step and the evidence still needed in a real integration. Record
what they actually identified and where they needed help. If alone, label the
record self-rehearsal.

Close with one concrete follow-up: the snapshot contract, a failure-classification
review or an independent output-support case. Name a role and the next evidence
to inspect. The route demonstrates inspectable engineering exercises and a
receiving explanation; model planning quality, field deployment and learner
qualification require their own evidence. A local exercise does not substitute
for the hosted learning-product walkthrough.

## The ten-minute story

### 0:00–1:00 — Show where the learner starts

**Show:** public course outline, free learning kit and the learner's discovery brief.
Point to the one-queue, one-location administrative forms task.

**Say:** “Free material gives a prospective engineer a concrete starting task.
The guided course builds a connected delivery packet. For this case, the
operator needs the current form-location instruction and retains review and
sending authority.”

**Ask the executive:** “Which operational decision would you need this packet
to support?” Capture the question; do not invent a customer goal or claim a saving.

### 1:00–3:00 — Follow one working implementation

**Show:** the Academy build-workflow lesson, the learner's small annotated diff,
and this command in the local practice folder:

```sh
node fde-client-delivery-starter.mjs supported
```

Point to `mode: offline-scripted`, `ADMIN-FORM-04`, version `3`, the authorization
and retrieval trace, and the operator's next action.

**Say:** “This run executes a local scripted adapter. The learner can inspect
where identity, scoped retrieval and output are separated before connecting a
model. A model adapter would sit inside this boundary; it would not own permissions
or sending. The implementation note tells us what was actually exercised.”

**Ask the developer:** “Where would you substitute an adapter, and which controls
must remain outside it?” Keep the answer tied to the code on screen.

### 3:00–5:00 — Let failure explain the design

**Show:** run these two cases and identify the first stage that stops each:

```sh
node fde-client-delivery-starter.mjs denied
node fde-client-delivery-starter.mjs withdrawn
```

The denied case stops before source lookup. The withdrawn case reaches scoped
retrieval and finds no current source. Both leave a clear next action.

**Say:** “The learner must explain why these outcomes differ. We evaluate the
path and the operator's next move, not just whether an answer sounds confident.”

If asked about agentic behavior, trace the intended sequence of task selection,
scoped source use, proposal and human action. Identify the part executed by the
script and the parts that would require a configured model and independently
authorized tools. These commands demonstrate deterministic control flow, not a
live agent autonomously selecting or invoking tools.

### 5:00–6:30 — Demonstrate engineering judgment

**Show:** the evaluation register and one contract counterexample:

```sh
node fde-output-contract-lab.mjs unsupported-claim
```

Point to `review-required` and `support: not-evaluated`, then compare the draft's
photo-ID requirement and completion promise with the actual source instruction.

**Say:** “A structurally valid result can still contain an unsupported claim.
The learner must identify it, record the evidence and request a precise revision.
The calibration exercise lets reviewers compare their reasoning without treating
agreement as proof of accuracy.”

Show one genuine revision from the chosen packet, or explicitly label the
presenter's authored before/after example. Do not submit or save work on behalf
of a learner during a sales demonstration.

### 6:30–8:00 — Give the receiver the controls

**Show:** run the timeout case, then let the receiver use the prepared runbook:

```sh
node fde-client-delivery-starter.mjs timeout
```

**Say:** “The local adapter deliberately stalls and returns a manual path.
Please tell us what you would do next, where you would find the approved
procedure, and which evidence you would give the receiving engineer.”

Stop coaching for up to 30 seconds. The receiver points to a manual action,
owner role and source/version evidence. The observer records a specific action
or hesitation. If a stop/restore step exists only on paper, identify it as a
tabletop step; do not claim this command stopped a deployed service.

### 8:00–9:00 — Show the individual contribution

**Show:** the portfolio index with the learner's contribution, original attempt,
review note and revision. Ask the learner or synthetic presenter to explain
one changed assumption without replaying a memorized slide.

**Say:** “Team delivery and individual capability are different evidence. We
want to see what this person built, why they changed it, and how they respond
when the task changes. Course participation and provider-issued credentials
remain separately evidenced.”

### 9:00–10:00 — Close with a concrete pilot decision

**Show:** the packet's recommended next scope and the workbook's review-capacity
arithmetic. Explain which figures are planning assumptions.

**Say:** “The next decision is a bounded pilot with a defined learner group,
receiving workflow, review capacity and acceptance evidence. We would observe
first-task completion, quality of revisions, reviewer effort and receiver
teach-back before proposing expansion.”

Record the buyer's requested next decision and an owner role. A demonstration
alone does not establish deployment capacity, field readiness or staffing outcomes.

## Five-minute discussion: answer with the artifact

| Audience question | Open this evidence | Useful answer boundary |
| --- | --- | --- |
| Executive: what changes for our teams? | First-slice agreement and whole-task baseline | State the proposed operational improvement and how it would be measured. |
| Technical leader: where is the model trusted? | Reviewed diff, source boundary and contract result | Identify executed controls, designed controls and the next unresolved case. |
| Engineer: can I reproduce this? | Versioned lab and original command output | Show one command and one changed fixture; distinguish original from modified results. |
| Workforce leader: can we scale the program? | Cohort capacity sheet and review assignments | Explain reviewer/support assumptions; do not equate seats with qualified engineers. |
| Investor: what is differentiated? | Connected packet and visible revision | Show the original curriculum and evidence workflow; leave traction and learning gains to measured evidence. |

## Recover cleanly if the room changes

If internet or account access fails, use the free workbook and local programs.
Say which protected steps are unavailable. If Node is unavailable, use the saved
output labeled recorded; do not stage a fake live run. If an unexpected result
appears, preserve it and use the remaining time to explain what it changes.
A demo-only repair is follow-up work, not something to hide while the audience waits.

If only five minutes remain, show the problem, the supported case, the unsupported
claim and one receiver action. Skip the capacity discussion and take it offline.
Never remove the execution-mode label or failure case to make the story smoother.

## Observation sheet

```text
Date / presenter / receiving role / observer:
Route selected / audience decision question:
Environment, file revision and evidence origin:
Observed mode: hosted product / local execution / recorded / tabletop:
Receiver action attempted without coaching:
Observed action or hesitation (quote or concrete behavior):
Artifact or instruction needing revision:
One change to make / responsible role:
Evidence that would demonstrate the repair:
Buyer's next decision / information needed:
```

Record performed actions, not “audience impressed.” Revise the highest-consequence
gap and repeat only the affected handoff step. A self-rehearsal stays self-rehearsal;
acceptance and learner outcomes require actual observations by the relevant people.