LockedIn FDE Training / The open field library
Build AI for the field.
Practical training for forward-deployed engineers. Turn a client problem into an agentic AI system you can explain, evaluate and hand over.
Start the free learning routeFree guides and labs. No account or API key required.
Preparing for your next team session? Find a guide by topic, vendor or the lab you want to run.
Have 20–35 minutes? Practice one decision.
Jump straight to a workbook exercise. Each includes a task, supplied material and something concrete to keep. These are optional sessions, not a completion checklist.
19 exercises · All practice
- 25minutes
Choose the right amount of autonomy
Compare direct lookup, a bounded draft, a fixed workflow and a model-directed loop against four client tasks.
Read the supplied synthetic brief; paper or your portfolio is enough.
Your working artifact
An architecture choice, simpler comparison and changed-brief revision.
Related Academy lessonRequires Academy access.
- 20minutes
Improve a decision with AI feedback
Write first, ask for one challenge, check the evidence and explain a fresh case without the coach.
Use the lesson coach with existing Academy access, or a peer with the supplied questions.
Your working artifact
A first attempt, supported revision and independent explanation.
Related Academy lessonRequires Academy access.
- 20minutes
Make your first bounded code change
Edit one request category, introduce a source conflict and confirm that unauthorized access still stops.
Node.js 24, the free starter and a plain-text editor; tabletop tracing is also available.
Your working artifact
A small explained diff, predictions and five observed outcomes.
Related Academy lessonRequires Academy access.
- 25minutes
Inspect a model-output contract
Run eight authored outputs through a local validator and explain why a valid citation cannot establish source support.
Node.js 24 and the free output-contract lab; no model account or API key.
Your working artifact
A contract trace, changed-fixture experiment and support-review gap.
Related Academy lessonRequires Academy access.
- 30minutes
Delegate agent work without multiplying authority
Trace two workers against one shared budget, reconcile conflicting references and keep a late result out of a completed manual task.
Read the synthetic worker packet; optional Node.js 24 replay needs no provider account or API key.
Your working artifact
A dispatch ledger, result-selection decision and changed-condition handoff.
Related Academy lessonRequires Academy access.
- 30minutes
Resume an agent without inheriting its assumptions
Repair a compressed handoff summary, separate memory from authority and revise the next step as access and source state change.
Read the six synthetic records; no model account, API key or code execution needed.
Your working artifact
A compact context packet, three continuation decisions and a receiver objection.
Related Academy lessonRequires Academy access.
- 30minutes
Trace an agent’s proposed tool calls
Run a local dispatcher and investigate revoked access, forbidden actions and a changed plan.
Node.js 24 for the free offline lab; no provider key or network call.
Your working artifact
An execution trace and a bounded tool specification.
Related Academy lessonRequires Academy access.
- 25minutes
Keep sources consistent across agent steps
Investigate a source revision and unversioned text change between reading and drafting, then challenge a misleading success result.
Node.js 24 and Edition 2 of the free tool-dispatch lab, or an explicitly unexecuted paper trace.
Your working artifact
A snapshot trace, changed-copy counterexample and receiving note.
Related Academy lessonRequires Academy access.
- 20minutes
Check source coverage before drafting
Compare incomplete and complete empty lookups, trace the next page and challenge a proposal built from different snapshots.
Node.js 24 and the free catalog-coverage lab, or a paper trace labeled unexecuted; no provider account.
Your working artifact
A coverage decision table, actual page trace and receiving note.
Related Academy lessonRequires Academy access.
- 30minutes
Keep an agent loop within its limits
Investigate failed attempts, resource limits, late drafts, cancellation and repeated work in a local controller.
Node.js 24 and the supplied offline lab; authored responses and virtual time.
Your working artifact
A stopping contract and a changed-boundary experiment.
Related Academy lessonRequires Academy access.
- 25minutes
Decide whether an agent should retry
Separate temporary failures from access and credential stops, then trace a wait and a late draft against one deadline.
Node.js 24 and Edition 2 of the free agent-loop lab, or a clearly labeled tabletop trace.
Your working artifact
A retry decision table, changed-boundary experiment and operator receiving note.
Related Academy lessonRequires Academy access.
- 30minutes
Keep changing sources reliable
Trace duplicate and late updates, withdrawals and conflicting revisions before deciding which source can be used.
Node.js 24 and the free source-lifecycle lab; sequential synthetic events only.
Your working artifact
Six event traces, a revision counterexample and a receiving contract.
Related Academy lessonRequires Academy access.
- 30minutes
Choose an AI route within the service contract
Compare two synthetic routes across twelve paired requests, then challenge a fallback budget and a one-millisecond deadline change.
Open the interactive comparison or use a spreadsheet with the free CSV; no provider account or live model call.
Your working artifact
A complete route comparison, scoped decision and receiving challenge.
Related Academy lessonRequires Academy access.
- 30minutes
Check whether an improvement transfers
Compare two fictional candidates across development and fresh tasks, preserving unrun boundaries and unsupported claims.
Read the supplied synthetic packet; no model account or code execution needed.
Your working artifact
A frozen decision rule, claim-level comparison and next-evidence recommendation.
Related Academy lessonRequires Academy access.
- 35minutes
Challenge a productivity claim
Calculate whole-task effort across twelve synthetic pairs, including rejected drafts and manual fallback.
A spreadsheet or calculator and the supplied synthetic CSV.
Your working artifact
A comparison table and a scoped value recommendation.
Related Academy lessonRequires Academy access.
- 25minutes
Design an agent trace without copying the payload
Inspect eight proposed events, separate model claims from application observations and preserve useful diagnostics without retaining sensitive content.
Read the synthetic trace packet; a text editor or paper is enough. No provider account or code execution.
Your working artifact
An event decision table, two repaired records and a receiving challenge.
Related Academy lessonRequires Academy access.
- 30minutes
Roll out a contract across client versions
Trace old browser sessions, design a compatible API response and defend both rollback directions without losing the operator's work.
Read the supplied synthetic client and API contracts; no account or code execution needed.
Your working artifact
A six-row compatibility matrix, deployment order and receiving challenge.
Related Academy lessonRequires Academy access.
- 30minutes
Make the operator's next action clear
Repair misleading states, preserve work through an interruption and let a receiver attempt the task unaided.
Paper sketches or a local practice prototype and the supplied synthetic case.
Your working artifact
An operator task, interruption contract and observed revision.
Related Academy lessonRequires Academy access.
- 30minutes
Review the evidence behind a rollout
Resolve two reviewers’ disagreement and update only the claims supported by a new candidate’s evidence.
Read the supplied packet; work alone or compare decisions with a peer.
Your working artifact
A traceable review decision and the smallest useful repair plan.
Related Academy lessonRequires Academy access.
Find a guide for your next session.
Choose the skill your team needs to practice. Check the lab setup, arrange a session shortlist and share it with your cohort. Each guide opens on its own; keep your attempt, evidence and next revision.
76 of 76 free guides
Prepare a team practice
Your session shortlist
Select up to 6 whole guides, then arrange their order. Choose an exercise, time boxes and a receiving check for each.
0 / 6 selected
Start from a prepared team session
Focused practice with exercise choices and receiving checks. Prepare the labs and reading beforehand; setup and breaks are separate. Preview a session, then adjust it for your team.
2 exercises · 80 planned min
Enterprise integration receiving
Receive uncertain HTTP work, then challenge a one-item queue replay against actual effects.
2 exercises · 80 planned min
Financial-services data handoff
Defend exact amount meaning, then reconcile the separate credit and posting evidence.
2 exercises · 80 planned min
Healthcare source handoff
Locate the referenced resource, then receive an eligibility observation without inventing approval.
2 exercises · 90 planned min
Verified event handoff
Verify delivered bytes, then swap builder and receiver roles to challenge pending and repeated events.
1 exercise · 60 planned min
Practitioner instructor teach-back
Rehearse a sixty-minute lesson: demonstrate a failure, let the learner act, then repair the explanation from observed evidence.
Use “Add to session” on a guide below. Prepare an agenda with setup requirements and individual evidence prompts.
Save or resume an editable plan
The Markdown agenda is for reading. Save an editable JSON file to continue planning later. File contents are read locally; opening one creates a preview. Guide content resolves against the current public catalogue.
Start guide
Your first client-delivery portfolio
Choose a starting route, prepare your workspace and plan six working sessions.
55-minute terminal lab
Understand your first command
Separate the terminal, shell, CLI and coding agent. Run a real local helper and inspect how arguments, folders and output channels change its result.
- Node.js
1 runnable companion · Setup and walkthroughs
First command and working directoryOpen lab walkthrough
Run five actual process cases and explain the report, diagnostics and exit code.
Node.js 24 · Standard library · No model or account
Git 101 + 30-minute merge lab
Git 101: know which change you are handing over
Define the working tree, staging area, commit and branch. Run real Git in a disposable repository and see why a passing working-copy check can describe different bytes from the commit.
- Python
2 runnable companions · Setup and walkthroughs
Git snapshot and evidence lab · PythonOpen lab walkthrough
Compare seven actual Git states, restage one edit and inspect an unrelated path added to the commit.
Python 3.11+ and Git 2.28+ · No account or network
Git merge and behavior lab · PythonOpen lab walkthrough
Observe a clean but broken merge, repair its caller against the same contract and inspect a real text conflict before abort.
Python 3.11+ and Git 2.28+ · Temporary local repositories · No network
35-minute testing lab
Tests 101: understand what a green result means
Define fixtures, assertions and the test runner. Compare six real Node.js runs and learn why filtering or weakening a check can hide a defect.
- Node.js
1 runnable companion · Setup and walkthroughs
Tests 101 · real Node.js runsOpen lab walkthrough
Compare assertion failures, setup errors, filtered execution, a repair and a weaker comparison.
Node.js 24 · Standard library · No model or network
Working reference
Client delivery workbook
Keep the shared case, practical exercises and artifact templates beside your work.
30-minute practice
Run a client discovery interview
Use stakeholder role cards to reconcile conflicting accounts and agree a useful first slice.
50-minute lab + optional token workshop
Identity 101: a login is not permission
Separate authentication, authorization and tenant scope. Follow a document through its access checks, then run five real local database cases before adding retrieval and agents. An optional workshop verifies real locally signed tokens before those reads.
- Package setup
- Python
2 runnable companions · Setup and walkthroughs
Token validation before document accessOpen lab walkthrough
Distinguish token rejection, missing action scope and a current document grant using actual local verification.
Python 3.11+ · Pinned PyJWT + cryptography · Fictional tokens · No account
Document access and tenant scopeOpen lab walkthrough
Compare an allowed read, missing identity, a tenant claim, a restricted record and a revoked grant.
Python 3.11+ standard library · No model, network or account
50-minute webhook proof workshop
Webhook verification: signed delivery is not new business work
Verify exact signed bytes, distinguish authentic stale messages from fresh repeats, and bind a business receipt to one local effect through ten offline HMAC and SQLite cases.
- Python
1 runnable companion · Setup and walkthroughs
Webhook byte verification and business event receivingOpen lab walkthrough
Compare authentic, tampered, stale, repeated and conflicting deliveries against actual local receipt/effect state.
Python 3.11+ · Standard-library HMAC and SQLite · Ephemeral keys · No network
50-minute retrieval proof workshop
Retrieval limits: an empty result can hide available evidence
Run actual SQLite FTS5 queries to compare late filtering, bounded overfetch and eligible result limits. Recheck changed grants and source revisions before assembling context.
- Python
1 runnable companion · Setup and walkthroughs
Retrieval candidate limits and current-source gatesOpen lab walkthrough
Compare actual ranked populations, changed grants and revisions without weakening context admission.
Python 3.11+ · Built-in SQLite FTS5 · Synthetic in-memory rows · No network or model
50-minute transport proof workshop
Trace context: a successful request can still have a broken trace
Execute real HTTP propagation with pinned OpenTelemetry. Compare dropped and reused parents, valid non-recording contexts and a bounded baggage policy without confusing trace evidence with task execution.
- Package setup
1 runnable companion · Setup and walkthroughs
HTTP trace propagation and sampled executionOpen lab walkthrough
Inspect actual HTTP carriers, SDK parent links, non-recording contexts and separately observed handler execution.
Python 3.11+ · Existing pinned OpenTelemetry packages · Owned loopback HTTP · No remote collector
45-minute healthcare source-value lab
FHIR values: false, zero and missing are different facts
Preserve explicit Boolean false and quantity zero, then compare reported absence, conflicting choices, result status and unit identity across fourteen synthetic Device Observations.
- Python
1 runnable companion · Setup and walkthroughs
FHIR value choices, presence, status and unitsOpen lab walkthrough
Retain false and zero, distinguish reported and unexplained absence, and withhold unsupported source forms without invented values.
Python 3.11+ · Standard library · Synthetic Device Observations · No network or patient data
50-minute healthcare reference lab
Locate a FHIR reference without changing its identity
Resolve synthetic FHIR R4 Bundle references with server base, UUID, contained scope and exact resource revision intact. Reverse entries to expose an ID-only shortcut and preserve unresolved lookup questions.
- Python
1 runnable companion · Setup and walkthroughs
FHIR reference identity and bounded Bundle lookupOpen lab walkthrough
Compare fullUrl, exact history version and contained scope; reverse entries without changing the guarded target.
Python 3.11+ · Standard library · Synthetic FHIR R4 subset · No health records or network
50-minute financial ledger proof lab
Double-entry posting: balanced does not mean correct
Execute balanced wrong-account, wrong-party and duplicate postings in SQLite. Compare partial writes with atomic rollback, then retain an original journal through reversal and correction.
- Python
1 runnable companion · Setup and walkthroughs
Double-entry meaning, atomic posting and correction historyOpen lab walkthrough
Expose balanced business errors, preserve incomplete-collection state after rollback and trace an original journal through correction.
Python 3.11+ · Standard library · In-memory SQLite · Fictional USD minor units · No network
50-minute financial amount-contract lab
Preserve the amount across a money contract
Execute unit and currency mismatches, actual JSON precision loss and explicit rounding policies. Give a receiving engineer exact amount evidence and the business rule still needing agreement.
- Node.js
1 runnable companion · Setup and walkthroughs
Exact money units, JSON and rounding contractsOpen lab walkthrough
Reproduce equal-number false matches, one lost JSON integer unit and mode/scope changes over unchanged calculation inputs.
Node.js 24 · Standard library · Synthetic nonnegative amounts · No financial writes or network
50-minute backfill recovery lab
Restart a backfill without losing the skipped work
Interrupt actual workers at three checkpoint boundaries, inspect committed SQLite rows and resume bounded batches. Reconcile a skipped row against a later source revision before claiming completion.
- Python
1 runnable companion · Setup and walkthroughs
Interrupted backfill and skipped-row reconciliationOpen lab walkthrough
Compare checkpoint-first, data-first and atomic restart, then reread a pending row after another source change.
Python 3.11+ · Standard library · Temporary SQLite files · Owned child processes · No network
50-minute queue recovery lab
Recover quarantined work without replaying the incident
Execute bounded failures, retained quarantine and a one-item replay. Compare an unchanged reader, a repaired reader and already-committed work; expose an extra effect from a changed business key.
- Python
1 runnable companion · Setup and walkthroughs
Queue quarantine and bounded replayOpen lab walkthrough
Inspect unchanged replay, reader repair and reuse of a committed effect; change only the replay business identity.
Python 3.11+ · Standard library · Temporary SQLite files · No broker or network
50-minute HTTP and reconciliation lab
Recover HTTP work when the response disappears
Run real loopback HTTP disconnects and an in-flight timeout. Reconcile matching receipts, challenge an early 404 and expose duplicate effects from a changed replay key.
- Python
1 runnable companion · Setup and walkthroughs
HTTP outcomes and receipt reconciliationOpen lab walkthrough
Observe disconnects on both sides of commit, a late effect after timeout, stable replay and a mismatched new-key receipt.
Python 3.11+ · Standard library · Owned loopback listener · Use --http
50-minute deadlock and receiving lab
PostgreSQL deadlocks: prove the cycle, then change the order
Capture an actual two-transaction wait cycle, inspect the full rollback, and compare statement-only retry, complete retry and consistent row order.
- Containers
1 runnable companion · Setup and walkthroughs
PostgreSQL deadlocks, retry scope and consistent row orderOpen lab walkthrough
Capture a real cycle and full rollback, execute two retry scopes, then compare a consistent lock order.
Python 3.11+ · Docker · Cached postgres:17 · Lifecycle companion · Use --deadlocks
45-minute transaction retry lab
PostgreSQL isolation: retry the decision, not just the update
Run overlapping database transactions, expose write skew and inspect an actual serialization failure. Compare a cached-decision retry with a fresh read before acting.
- Containers
1 runnable companion · Setup and walkthroughs
PostgreSQL isolation and full transaction retryOpen lab walkthrough
Observe five actual two-connection cases and change capacity while retaining the read, decision and committed effects.
Python 3.11+ · Docker · Cached postgres:17 · Lifecycle companion · Use --write-skew
45-minute PostgreSQL concurrency lab
PostgreSQL lock waits: a compatible change can still queue your readers
Observe three actual PostgreSQL sessions, identify a waiting schema change that delays a later reader, and compare cancellation, lock timeout and transaction release.
- Containers
1 runnable companion · Setup and walkthroughs
PostgreSQL lock queues · PythonOpen lab walkthrough
Inspect actual hard and soft blockers across three sessions, then distinguish a refused DDL attempt from an applied change.
Python 3.11+ · Docker · Cached postgres:17 · Keep lifecycle companion beside runner
45-minute role-policy lab + 30-minute session workshop
PostgreSQL row security: test the role that actually reads
Run real PostgreSQL role and row-policy checks. Observe default denial, rejected writes, privileged bypass and permissive policies, then trace request context across one reused connection.
- Containers
1 runnable companion · Setup and walkthroughs
PostgreSQL roles and row policiesOpen lab walkthrough
Observe ordinary grants, RLS policies, write checks, bypass roles, permissive policy composition and a denied role switch in an isolated scratch database.
Python 3.11+ · Local Docker · Cached PostgreSQL 17 image · No cloud or existing database
80-minute lab + optional query and snapshot workshops
Data 101: a document, a record and a searchable copy
Separate object storage, relational records and search. Run real local file reads, SQL queries and transactions, then catch a stale copy and an incomplete update.
- Python
3 runnable companions · Setup and walkthroughs
SQL values, scope and search meaningOpen lab walkthrough
Compare interpolation, bound values, a missing workspace condition and literal versus wildcard matching using actual returned rows.
Python 3.11+ with SQLite · In-memory fictional rows · No packages or network
Read snapshots across two connectionsOpen lab walkthrough
Observe a mixed read, a coherent older snapshot, deferred BEGIN and an uncommitted writer; hand over the exact read boundary.
Python 3.11+ with SQLite WAL · Temporary local database · No packages or network
Document, record and search lifecycleOpen lab walkthrough
Compare source and copy changes, then inspect transaction boundaries and actual foreign-key enforcement.
Python 3.11+ with SQLite · Standard library · No model or cloud
40-minute concurrency proof lab
Coalesce cache misses without sharing the wrong promise
Make callers share one in-flight build, then challenge leader failure, a real waiter timeout, changed source input and separate workspace keys. Keep each caller's evidence distinct.
- Python
1 runnable companion · Setup and walkthroughs
In-flight sharing, failure cleanup and waiter deadlinesOpen lab walkthrough
Compare duplicate builds with joined work, preserve a waiter's timeout and clear a failed leader before a later call.
Python 3.11+ · Standard library · Owned threads · No network, model or database
45-minute HTTP cache proof lab
HTTP caching: select the right copy before reusing it
Run actual local HTTP requests to expose a wrong-language fresh hit, validate a stored body with 304 and distinguish no-cache, no-store and Vary star.
- Python
1 runnable companion · Setup and walkthroughs
HTTP variants, revalidation and retentionOpen lab walkthrough
Expose a wrong-language hit, inspect real 304/200 exchanges and withhold an orphan validation response.
Python 3.11+ · Standard library · Owned loopback HTTP · No outside requests
45-minute caching lab + 25-minute publication proof
Caching 101: when can you reuse earlier work?
Understand hits, expiry and invalidation, then reproduce a late publisher overwriting newer work. Check the authoritative source even after a cache entry disappears.
- Python
2 runnable companions · Setup and walkthroughs
Caching 101 · local SQLite labOpen lab walkthrough
Distinguish safe reuse, changed sources, workspace scope, revoked access, unavailable evidence and expiry.
Python 3.11+ · Standard library · No model or network
Late cache publication · process proofOpen lab walkthrough
Pause an old publisher, commit a newer source and compare atomic publication with a cache-row-only check after deletion.
Python 3.11+ · Temporary SQLite file · Owned child process · No network
40-minute practice
Investigate retrieval before trusting the answer
Trace eight source-backed answers through tenant scope, effective dates, conflicting evidence and unsupported claims.
30-minute practice
Calibrate draft review
Compare six synthetic drafts with their evidence and explain your review decisions.
35-minute practice + optional executable lab
Recover an agent action when the receipt is missing
Investigate uncertain actions, then execute a two-database outbox crash: compare duplicate effects, guarded replay and changed requests before handing over recovery.
- Python
1 runnable companion · Setup and walkthroughs
Outbox crash and destination replayOpen lab walkthrough
Crash after a destination commit, compare naive and guarded redelivery, and reject a changed payload without closing the original pending work.
Python 3.11+ · Two temporary SQLite databases · Owned child processes · No network
A2A 101 + optional SDK lab
A2A 101: follow an agent’s first handoff
Separate messages, tracked tasks, context and artifacts. Follow a missing-input request, then compare a local model with a real Python SDK exchange over loopback HTTP.
- Node.js
- Package setup
2 runnable companions · Setup and walkthroughs
First agent handoffOpen lab walkthrough
Trace a clarification, wrong-task refusal, held artifact and a new task in the same conversation.
Node.js 24 · Standard library · No model, network or account
A2A SDK over local HTTPOpen lab walkthrough
Discover the real local agent card, continue a tracked task and hold a completed result with the wrong source.
Python 3.11+ · Fresh environment · Five pinned packages · No model or key
Agent engineering lab
Build and test a bounded AI agent
Run real LangChain tool loops and LangGraph SQLite restart labs, compare broken candidates and inspect source-bound review without a provider key.
- Python
- Node.js
- Package setup
18 runnable companions · Setup and walkthroughs
Durable workflow referenceOpen lab walkthrough
Pause a draft, restart the process and bind a review decision to its exact source.
One Python file · No package installation
Scoped retrieval and contextOpen lab walkthrough
Compare retrieval quality on eight cases while preserving current access and context budgets.
Python standard library · Standalone file
Regression comparison labOpen lab walkthrough
Compare the working reference with broken candidates and retain missing-case evidence.
Python standard library · Keep the workflow file beside it
MCP tool admissionOpen lab walkthrough
Challenge changed tool definitions, forged arguments and current host permissions.
Node.js 24 · Offline host-policy exercise
Shared delegation coordinatorOpen lab walkthrough
Trace retries, shared attempt limits and late results after manual closure.
Node.js 24 · Supplied event replay
Worker lease and recoveryOpen lab walkthrough
Compete for one lease across two local processes, then rehearse a worker kill and recover without resetting attempts.
Python standard library · SIGKILL extension on macOS/Linux
LangGraph SQLite restartOpen lab walkthrough
Recover saved work, distinguish retry from review, and route two independent decisions by interrupt ID.
Python 3.11+ · New virtual environment · Three pinned packages
LangGraph interrupt and resumeOpen lab walkthrough
Wire a real StateGraph, observe an interrupt and resume its in-memory state.
Python 3.11+ · New virtual environment · Pinned LangGraph package
LangChain tool-calling loopOpen lab walkthrough
Inspect real create_agent orchestration using scripted tool proposals and results.
Python 3.11+ · New virtual environment · Pinned framework packages
Structured agent outputOpen lab walkthrough
Run real ToolStrategy validation and repair, then distinguish a valid shape from current source support.
Python 3.11+ · New virtual environment · Pinned framework packages
Receiver commit and replayOpen lab walkthrough
Compare a duplicate-producing receiver with an atomic effect and receipt, then retry a lost response.
Python standard library · Owned child-process exits
Agent trace and payload boundaryOpen lab walkthrough
Keep bounded observability events, then inspect optional real OpenTelemetry spans without a collector.
Core: Python 3.11+ · Standard library · Optional SDK extension
MCP stdio compatibilityOpen lab walkthrough
Inspect real framed requests and distinguish a tool refusal from a protocol failure.
Node.js 24 · Owned child process · Pinned 2025-11-25 profile
Agent canary evidenceOpen lab walkthrough
Compare candidate/control segments, retain missing evidence and stop an aggregate-green regression.
Python 3.11+ · Standard library · Supplied observation packets
MCP SDK client and serverOpen lab walkthrough
Compare tools, resources and prompts through real SDK calls, then inspect schema and permission refusals.
Node.js 24 · New npm folder · Three pinned packages
Private inference capacityOpen lab walkthrough
Budget weights, KV cache, context and output reservations without claiming measured GPU capacity.
Python 3.11+ · Standard library · No GPU or model
Your first LangGraph workflowOpen lab walkthrough
Trace two ordinary functions, field updates and a missing-source branch before adding persistence.
Python 3.11+ · Isolated environment · LangGraph 1.2.16
Your first HTTP request with FastAPIOpen lab walkthrough
Follow real requests through routing, validation, Python functions and four distinct responses.
Python 3.11+ · Isolated environment · Supplied pinned requirements
45-minute Model 101 lab
Model 101: from learned patterns to generated text
Understand parameters, context and inference before building an agent. Train a tiny inspectable model, follow token selection and change one cause at a time.
- Python
1 runnable companion · Setup and walkthroughs
Train and inspect a tiny language modelOpen lab walkthrough
Compare learned counts, token probabilities, generated text and parameter fingerprints.
Python 3.11+ standard library · No GPU, network or account
35-minute tokenizer lab
See tokens before planning a model request
Inspect actual text-to-ID conversion, compare encoding dictionaries and reserve room for an answer in a small local exercise.
- Package setup
1 runnable companion · Setup and walkthroughs
First tokenization and request budgetOpen lab walkthrough
Reproduce real token boundaries and compare fit with over-capacity before any model call.
Python 3.11+ · Pinned packages · Cache dictionaries once
40-minute context lab
Give the model the right working packet
Understand context, compare useful and lossy summaries, and refresh stale facts in an original offline exercise.
- Python
1 runnable companion · Setup and walkthroughs
First context packetOpen lab walkthrough
Build real JSON packets and compare information loss and freshness without calling a model.
Python 3.11+ standard library · No installation or account
40-minute structured-output lab
Read your first output contract
Connect ordinary response fields to real JSON Schema validation, then compare a valid shape with the source that should support it.
- Package setup
1 runnable companion · Setup and walkthroughs
First output contractOpen lab walkthrough
Reproduce nine responses and explain the first boundary that holds each one.
Python 3.11+ · Pinned jsonschema validator · No model
45-minute embedding lab
Turn a sentence into a search result
Run a real local embedding model, inspect its numeric output and compare a paraphrase, a contradiction and a question with no answer.
- Package setup
1 runnable companion · Setup and walkthroughs
Your first embedding searchOpen lab walkthrough
Inspect real 384-value embeddings and reproduce four retrieval cases without a provider key.
Python 3.11+ · Pinned packages · CPU · Prepare about 91 MB once
40-minute lab + optional BM25 workshop
Combine searches without confusing rank with truth
See keyword and semantic searches become one ranked list. Calculate reciprocal rank fusion, vary the candidates and explain why a high rank can still be the wrong evidence.
- Python
2 runnable companions · Setup and walkthroughs
BM25 ranking · actual SQLiteOpen lab walkthrough
Inspect actual indexed terms and scores, change document length and collection size, then preserve an empty result.
Python 3.11+ with SQLite FTS5 · Standard library · Offline
Hybrid search proof labOpen lab walkthrough
Reproduce keyword ranking and rank fusion with verified recorded embedding scores, then change the candidate input.
Python 3.11+ · Standard library · Offline
45-minute graph retrieval lab
Knowledge graphs: follow a relationship to its evidence
Start with entities, relationships and source provenance. Trace a dependency map, run real SQLite queries and explain missing evidence, unverified claims and cycles.
- Python
1 runnable companion · Setup and walkthroughs
Graph retrieval proof lab · SQLiteOpen lab walkthrough
Traverse actual relationships, withdraw a source, compare an unverified claim and terminate a cyclic traversal.
Python 3.11+ · Standard library · Offline
45-minute source lifecycle lab
Keep retrieval current when the source changes
Understand a search index as a maintained copy. Follow a correction, delayed job and deletion through real SQLite search results and the context boundary.
- Python
1 runnable companion · Setup and walkthroughs
Source and search lifecycle · SQLite FTS5Open lab walkthrough
Correct a source, replace the search copy, reject a late job and prevent resurrection after deletion.
Python 3.11+ with SQLite FTS5 · Offline · No packages
45-minute evaluation lab
Run your first AI evaluation
Start with what a good result means, compare three simple candidates on the same six requests, and inspect the mistakes behind a score.
- Python
1 runnable companion · Setup and walkthroughs
First evaluation comparisonOpen lab walkthrough
Reproduce three candidate reports and explain how equal scores hide different failures.
Python 3.11+ standard library · No account or installation
40-minute observability lab
Read your first request trace
Connect familiar Python functions to real spans, compare a missing guide with a failed lookup, and investigate a gap in the record.
- Package setup
1 runnable companion · Setup and walkthroughs
First request traceOpen lab walkthrough
Generate real local spans and explain their relationships, outcomes and observation gaps.
Python 3.11+ · Pinned OpenTelemetry SDK · No collector
45-minute REST API lab
REST API 101: read a resource, change it deliberately
Define resources, representations and HTTP methods. Run seven local request sequences, inspect repeated operations and keep an older edit from overwriting newer work.
- Python
1 runnable companion · Setup and walkthroughs
REST resource lifecycle · local HTTPOpen lab walkthrough
Compare actual reads, creations, replacements and deletions; inspect stale and missing conditions.
Python 3.11+ standard library · Loopback only · Fictional tickets
45-minute cloud networking lab
Cloud networking 101: read an address plan
Understand IP addresses, CIDR, subnets and routes before configuring a cloud. Predict seven real calculations and separate address capacity from permission and reachability.
- Python
1 runnable companion · Setup and walkthroughs
CIDR, overlap and route selection · PythonOpen lab walkthrough
Calculate actual range membership, overlaps and route choices; compare provider reservation assumptions.
Python 3.11+ standard library · Offline · No cloud account
40-minute networking lab
Reach a service before debugging the agent
Understand name lookup, TCP, TLS and HTTP. Run five real local connection cases and distinguish a failed connection from a refused resource.
- Package setup
1 runnable companion · Setup and walkthroughs
First TCP, TLS and HTTP connectionOpen lab walkthrough
Compare verified responses, TCP failure and certificate rejection without a cloud account.
Python 3.12 · Pinned cryptography package · Loopback connections
65-minute container lab
Understand what survives a container replacement
An image is the package; a container is one instance. Follow a pending review through a visual lifecycle, then run a real local API to compare restart, replacement and a mounted volume.
- Containers
1 runnable companion · Setup and walkthroughs
Container lifecycle · local APIOpen lab walkthrough
Observe a pending review disappear without a volume and survive replacement when its storage is explicitly retained.
Local Docker Engine or Desktop · curl · Internet for image preparation
40-minute Queue 101 lab
Follow a job from accepted to finished
Understand messages, workers and acknowledgements. Compare lost work, duplicated work and a safely reused result with a visual walkthrough and real local database writes.
- Python
1 runnable companion · Setup and walkthroughs
Queue delivery and business effectsOpen lab walkthrough
Compare missing, duplicated and reused drafts across four delivery cases; change the replay identity and explain the result.
Python 3.11+ standard library · Offline synthetic data
40-minute configuration lab + 30-minute rotation proof
Configuration 101: what did the program actually load?
Trace settings into a running process, then observe two replicas through credential overlap, early revocation and rollback with safe diagnostics.
- Node.js
2 runnable companions · Setup and walkthroughs
Configuration 101 · real local processesOpen lab walkthrough
Observe loading, inherited precedence, validation, file edits and process-local changes.
Node.js 24 · Standard library · No model or network
Two-replica credential rotationOpen lab walkthrough
Observe partial rollout, early revocation and rollback using per-process startup state and actual local authentication responses.
Node.js 24 · Owned child processes · Loopback HTTP · Generated fixtures only
45-minute SDK 101 lab
SDK 101: follow your first client call
Separate the client SDK, API, endpoint and model. Compare raw HTTP with a real client library, observe retries and timeouts, and decide which responses your application can use.
- Package setup
1 runnable companion · Setup and walkthroughs
SDK requests and response decisionsOpen lab walkthrough
Observe a real client sending HTTP requests, retrying a 503, surfacing a 400 and timing out; inspect an unexpected 200 response.
Node.js 24 · Anthropic SDK 0.131.0 · Registry access for installation
40-minute lab + optional cancellation workshop
Streaming 101: when is a response actually finished?
See how bytes become events and a partial draft becomes a reviewable result. Compare six local HTTP responses, including interrupted streams and incomplete messages.
- Node.js
2 runnable companions · Setup and walkthroughs
Client cancellation and server effectsOpen lab walkthrough
Abort three real response streams, then query the recorded rows to distinguish continued work, a cooperative stop and a prior write.
Node.js 24 · Built-in SQLite · Ephemeral loopback HTTP · No packages or model
Streaming 101 · real local HTTPOpen lab walkthrough
Reconstruct events across byte boundaries, withhold interrupted output and expose a premature-completion defect.
Node.js 24 · Standard library · Loopback only · No model
45–60 minute cloud AI lab
Understand a model response before acting
An adapter translates a service response into a decision your application can use. Compare Google Cloud, AWS and Azure, predict the next step, then run and change the local Python example.
- Python
1 runnable companion · Setup and walkthroughs
Cloud model response adapterOpen lab walkthrough
Distinguish text, an output limit, a function proposal and an unsupported response across three providers.
Python 3.11+ standard library · No account, model or network
NVIDIA systems lab
Plan an NVIDIA AI deployment
Trace CPU-to-GPU work, follow a model request through serving and explain its delay. Compare model partitions, protect evaluation data and inspect critical regressions before making a deployment decision.
- Python
6 runnable companions · Setup and walkthroughs
Collective results · CPU process labOpen lab walkthrough
Compare complete and partial vectors, sum compatible contributions, inspect both recipients and refuse an incorrect count.
Python 3.11+ standard library · Two CPU workers · No GPU or network
Model improvement · offline evidence labOpen lab walkthrough
Find cross-partition leakage, compare supplied review outcomes and explain why a critical regression outweighs an improved total.
Python 3.11+ standard library · No model, GPU or account
GPU model placement · offline labOpen lab walkthrough
Compare replicas and model partitions, then check each GPU memory budget and identify missing deployment evidence.
Python 3.11+ standard library · No GPU or account
Model serving timing · offline traceOpen lab walkthrough
Separate queue, prompt-processing and delivery delay; calculate first-token and last-token timing.
Python 3.11+ standard library · No GPU or account
CUDA work assignment · CPU-only traceOpen lab walkthrough
Trace valid writes and guarded skips while changing grid and block sizes.
Python 3.11+ standard library · No GPU or account
GPU capacity and cost labOpen lab walkthrough
Find a memory admission boundary and compare hypothetical rent/own scenarios.
Python 3.11+ standard library · No GPU or account
Gateway lab + shared-budget extension
Control AI traffic with a gateway
An AI gateway sits between your application and model services. Test identity, token budgets and approved routing, then make two workers compete for one shared SQLite budget before mapping the contract to a deployed gateway.
- Python
2 runnable companions · Setup and walkthroughs
AI gateway admission and token budgetsOpen lab walkthrough
Compare overlapping reservations, reject forged budget hints and refuse an unapproved fallback.
Python 3.11+ standard library · Offline synthetic requests
Shared gateway budget · concurrent SQLite workersOpen lab walkthrough
Expose a lost debit, enforce conditional admission, verify rollback and let both smaller requests through.
Python 3.11+ · Standard library · Temporary SQLite · No network or model
60-minute security lab
Prompt injection: text is not permission
Learn what prompt injection is, follow a tool request through its permission check, and inspect the unwanted text that can survive in an allowed draft.
- Node.js
2 runnable companions · Setup and walkthroughs
Prompt injection and tool authorityOpen lab walkthrough
Observe a denied send, a rejected authority claim and a permitted draft that still contains unwanted instructions.
Node.js 24 · Offline authored proposals
Exact-action approval and replayOpen lab walkthrough
Reject changed reviewed data and revoked permission; replay one completed operation without a second local effect.
Node.js 24 · Standard library · Synthetic approval · Nothing sent
45-minute governance lab
AI governance 101: from a policy to a reviewable decision
Define policy, control, evidence and decision. Follow a draft assistant through changed models, sources, tools and an incident report, then write the next reviewable action.
- Python
1 runnable companion · Setup and walkthroughs
Governance evidence comparisonOpen lab walkthrough
Distinguish matching, stale, missing, failed and unrun records while preserving incident reports and human decision ownership.
Python 3.11+ standard library · Fictional records · No model or network
35-minute practice + offline extension
Plan cohort review capacity
Put review work and revision delays on a calendar before committing to the next intake.
- Python
1 runnable companion · Setup and walkthroughs
Review-lane allocation and schedule checksOpen lab walkthrough
Challenge a proposed date against role capacity, reserved time and predecessor constraints; preserve unfinished work.
Python 3.11+ · Standard library · Synthetic artifacts · No network
35-minute practice + offline extension
Defend a changed client brief
Revisit your decision when a source, permission or productivity assumption changes.
- Node.js
1 runnable companion · Setup and walkthroughs
Late-result release and receiver checksOpen lab walkthrough
Complete actual pending Promises after permission or request state changes; distinguish server release from receiver acceptance.
Node.js 24 · Standard library · Synthetic state · No network
Industry proof workbook
Healthcare operations: business language to code proof
Understand eligibility, authorization and payment. Run a synthetic handoff lab, expose an unsupported conclusion and rehearse an industry mentor review.
- Python
1 runnable companion · Setup and walkthroughs
Healthcare handoff proof labOpen lab walkthrough
Inspect actual SQLite notes across ten healthcare cases and a deliberately broken meaning check.
Python 3.11+ · standard library only · synthetic data
50-minute FHIR lab
FHIR eligibility: read the answer before saying approved
Understand FHIR, match an eligibility response to its business question and run fifteen synthetic cases that keep a missing requirement separate from approval or payment.
- Python
1 runnable companion · Setup and walkthroughs
FHIR eligibility interpretation labOpen lab walkthrough
Inspect fifteen real interpretations, reproduce an invented negative answer and match the intended plan.
Python 3.11+ · standard library only · synthetic FHIR R4 subset
45-minute terminology lab
Healthcare terminology: the same label can mean a different service
Define Coding, CodeSystem, ValueSet and ConceptMap. Run fourteen synthetic mapping cases and prove why matching display text can change the business question.
- Python
1 runnable companion · Setup and walkthroughs
Healthcare terminology mapping labOpen lab walkthrough
Inspect fourteen mappings, reproduce a false label match and preserve versions, direction and unresolved meaning.
Python 3.11+ · standard library only · invented FHIR R4 subset
50-minute integration lab
Healthcare integration: keep the service identity across the handoff
Connect terminology mapping to eligibility interpretation. Follow the version across both systems, run fourteen cases and expose a condition that component tests miss.
- Python
1 runnable companion · Setup and walkthroughs
Connected healthcare proof labOpen lab walkthrough
Run fourteen connected cases and prove why a successful component can still lose a required vocabulary version.
Python 3.11+ · Unzip three Python files and workbook · No packages
Industry proof workbook
Financial-services operations: evidence before action
Separate provisional credit from a final outcome. Build a synthetic dispute handoff, prove its authority and retry boundaries, and prepare a receiving-owner review.
- Python
1 runnable companion · Setup and walkthroughs
Financial-services handoff proof labOpen lab walkthrough
Inspect actual SQLite notes across ten financial-services cases and a deliberately broken meaning check.
Python 3.11+ · standard library only · synthetic data
50-minute reconciliation lab
Financial reconciliation: when matching amounts are not enough
Learn case and ledger matching, distinguish a repeated delivery from two credit entries, and run thirteen synthetic comparisons before handing over an exception.
- Python
1 runnable companion · Setup and walkthroughs
Case-to-ledger reconciliation labOpen lab walkthrough
Compare thirteen actual read-only results, reproduce a false match and investigate duplicate entry identities.
Python 3.11+ · standard library only · synthetic USD records
45-minute adapter proof lab
Read every page before claiming the credit is missing
Build a scoped pagination adapter. Follow the credit onto a second page, reproduce false missing-credit and false-match results, and withhold incomplete evidence.
- Python
1 runnable companion · Setup and walkthroughs
Paginated financial extract labOpen lab walkthrough
Collect thirteen local response scenarios, compare two broken modes and prove when reconciliation must not run.
Python 3.11+ · standard library · keep both files together
50-minute transaction proof lab
Save the reviewed note, not a stale decision
Use two real SQLite connections to prove stale review, overlapping deliveries, durable retries and rollback. Explain which facts still support a new internal note.
- Python
1 runnable companion · Setup and walkthroughs
Financial handoff transaction labOpen lab walkthrough
Run seven cases, move one read across the transaction boundary and inspect actual committed rows.
Python 3.11+ · standard library · disposable SQLite databases
25-minute review + optional packet rehearsal
Review a portfolio with a receiver
Trace six artifacts, attempt one receiving task and request a revision another engineer can verify.
45-minute unit economics lab
Unit economics 101: what does a useful result cost?
Separate a requested task, a model attempt and an accepted outcome. Trace complete delivery cost, run six fictional cases and challenge the cheaper-model assumption.
- Python
1 runnable companion · Setup and walkthroughs
Cost per accepted outcomeOpen lab walkthrough
Compare complete costs, distinct accepted tasks, retries, review effort and a zero-outcome case.
Python 3.11+ standard library · Fictional rates · No network or model
Codex 101 + free runtime lab
OpenAI Codex: build a reviewed change
Understand the coding agent, run a free application-dependency experiment, then prepare a reviewed change in the protected workshop.
- Node.js
1 runnable companion · Setup and walkthroughs
Application runtime dependency labOpen lab walkthrough
Compare four actual process results and request records, then change one synthetic response without changing application source.
Node.js 24 · Standard library · Temporary loopback server · No model account
Systems workshop · local proof labs
Data, infrastructure & recovery
Trace server state, query plans and Terraform changes, then inspect restored data and competing failover histories.
- Python
- Package setup
6 runnable companions · Setup and walkthroughs
Processes, HTTP and stateOpen lab walkthrough
Trace two real server processes to their stores, change the saved value and compare restart with replacement.
Python 3.11+ · Real loopback HTTP · Temporary SQLite files · No cloud
SQL query plans and index keysOpen lab walkthrough
Compare five actual query plans, inspect key groups and change scope, status or row count.
Python 3.11+ · SQLite standard library · In-memory synthetic rows
Database restore and application compatibility labOpen lab walkthrough
Restore actual rows, inspect a failing application query and change recovery-point and acceptance times.
Python 3.11+ · Standard library · Synthetic data · No network
Terraform plans, inputs and stale-state experimentOpen lab walkthrough
Run five actual plan/apply cases and change the contract inputs independently.
Python 3.11+ and approved Terraform 1.4+ (<2) · Temporary local state
Terraform local state contractOpen lab walkthrough
Plan and apply a local state change without creating infrastructure.
Terraform 1.4+ · Built-in provider · No cloud account
Failover data historiesOpen lab walkthrough
Inspect missing accepted work, conflicting histories and stale failback, then change the uncopied rows.
Python 3.11+ · Temporary SQLite files · Scripted routing · No network
Measurement workshop + uncertainty lab
AI evaluation & decision science
Follow routing decisions into a confusion matrix, then inspect dataset independence, grader mistakes and full outcome costs. Reproduce the calculations with editable synthetic evidence.
- Python
4 runnable companions · Setup and walkthroughs
Routing thresholds and confusion matrixOpen lab walkthrough
Trace each draft into the counts, change a score and preserve missing labels and restricted-case findings.
Python 3.11+ · Authored scores and references · No model or network
Whole-task cost and accepted outcomesOpen lab walkthrough
Trace rejected work, missing bills and setup assumptions before pricing an accepted outcome.
Python 3.11+ · Decimal arithmetic · Fictional records · No model or network
Evaluation metrics and dataset checkerOpen lab walkthrough
Calculate fixture metrics, compare four dataset splits and inspect your changed synthetic manifest.
Python 3.11+ · Standard library · Synthetic cases · No model or network
Grader calibration and answer-order labOpen lab walkthrough
Compare agreement with reference match, inspect shared mistakes and remap a reversed answer order.
Python 3.11+ · Authored judgments · No model or network
Integration proof workshop
Enterprise integration & safe change
Follow receiving rows through late, repeated and out-of-order updates, then test API meaning, timestamp ambiguity, transaction boundaries and old/new compatibility with runnable local experiments.
- Python
6 runnable companions · Setup and walkthroughs
Event order and receiving rowsOpen lab walkthrough
Trace snapshots, deltas, pending receipts and conflicts; change the delivery order without changing its independent reference.
Python 3.11+ · Actual scratch SQLite · Fictional item counts · No network
API contract consumersOpen lab walkthrough
Execute three consumers against six producer changes, then edit a versioned response while preserving its independent expected value.
Python 3.11+ · JSON and Decimal · Fictional USD quotes · No network
Timestamp meaning, units and ambiguous local timeOpen lab walkthrough
Compute one, two or zero UTC candidates; change an offset and distinguish a valid conversion from the intended event.
Python 3.11+ · Installed IANA time-zone data · Historical fictional events · No network
Transactional integration labOpen lab walkthrough
Reproduce six transaction traces, change a retry identity and verify old/new reader compatibility.
Python 3.11+ · SQLite · Temporary synthetic databases · No network
Migration compatibility labOpen lab walkthrough
Probe old and new readers through six migration sequences, then change and replay a conditional backfill.
Python 3.11+ · SQLite 3.35+ · In-memory fictional record · No network
Retry budgets and amplificationOpen lab walkthrough
Trace nested retry layers, share an attempt budget and distinguish a deadline from an observed response.
Python 3.11+ · Logical-time read simulation · No network or SDK
Operations workshop
Reliable services & operational ownership
Record a real request trace, inspect overlapping calls and missing context, then investigate user reliability and misleading monitoring traffic. Calculate reliability, model bounded queues, verify release evidence and reconstruct what responders know during an incident.
- Package setup
- Python
6 runnable companions · Setup and walkthroughs
Service traces and concurrent workOpen lab walkthrough
Record overlapping calls, distinguish missing spans from detached context, and change one deliberate wait.
Python 3.11+ · Pinned OpenTelemetry SDK · Actual local spans and SQLite · No network after setup
Reliability and queue labOpen lab walkthrough
Compare four reliability windows, change a request record and account for bounded queue work.
Python 3.11+ · Synthetic arithmetic and simulation · No load test or deployment
Queue capacity and deadlinesOpen lab walkthrough
Follow six jobs through four capacity conditions; change the waiting limit and distinguish admission from on-time completion.
Python 3.11+ · Logical-time simulation · No traffic or infrastructure
Artifact signatures and release evidenceOpen lab walkthrough
Verify real signatures, trace changed bytes and discover why a trusted signature can still describe the wrong source.
Python 3.11+ and approved OpenSSL 3 · Temporary synthetic files
Incident timeline and outcome reconciliationOpen lab walkthrough
Separate worker readiness from known outcomes, delay a receipt and challenge conflicting evidence.
Python 3.11+ · Scratch SQLite · Invented observations · No network
Receiver rehearsal: live, ready and usefulOpen lab walkthrough
Compare process health with a real task, identify the wrong probe target and change the required revision.
Python 3.11+ · Actual loopback HTTP · Read-only SQLite queries · Temporary local processes
Field and receiving-review workbook
Human-centered AI delivery
Map work, waiting and dependencies before proposing automation. Change a timing assumption, rehearse review and accessible recovery, then compare pilot outcomes without hiding case mix or missing evidence.
- Python
- Browser
4 runnable companions · Setup and walkthroughs
Work, waiting and dependenciesOpen lab walkthrough
Change drafting time, inspect parallel waits and expose an invalid handoff caused by a missing dependency.
Python 3.11+ · Invented cases · No packages or network
Human–AI review and confirmation labOpen lab walkthrough
Compare review with saved effects across four conditions, then change the proposal and verify the execution boundary.
Python 3.11+ · SQLite · Fictional ticket · No network
Keyboard, errors and recovery · browser labOpen lab walkthrough
Use real keyboard focus and field corrections, preserve a draft and distinguish an unsent request from missing confirmation.
Download and open locally · Modern browser · No packages, model or network
Pilot case mix and outcome comparisonOpen lab walkthrough
Expose a misleading headline, compare a shared case mix and retain pending or unobserved outcomes.
Python 3.11+ · Invented case records · No packages or network
40-minute process lifecycle lab
Stop a service without abandoning accepted work
Follow an actual HTTP request through graceful draining, a forced stop and a grace deadline. Give the receiving team a clear admission and completion contract.
- Node.js
1 runnable companion · Setup and walkthroughs
Graceful shutdown · actual HTTP and signalsOpen lab walkthrough
Keep an accepted request separate from late work; inspect actual client responses, interrupted connections and process exit.
Node.js 24 · macOS, Linux or WSL · Standard library · Loopback only
40-minute collection consistency lab
Keep a changing collection intact across pages
Run actual SQLite pagination, expose repeated and missing records, and compare a changing list with a retained read snapshot. Define what completeness means for the receiving team.
- Python
1 runnable companion · Setup and walkthroughs
Pagination and read snapshots · SQLiteOpen lab walkthrough
Compare offset, keyset, upper-bound and snapshot traversal while a separate writer commits changes.
Python 3.11+ · Standard library · Temporary SQLite WAL database · No network
40-minute compatibility lab
Keep old clients working through an API rollout
Execute mixed-version HTTP exchanges, catch a misleading Complete state and defend client/server rollback separately. Give a receiving engineer reproducible evidence.
- Node.js
1 runnable companion · Setup and walkthroughs
Contract rollout · real local HTTPOpen lab walkthrough
Compare old and new consumers against actual HTTP responses; preserve manual work and expose a removed compatibility branch.
Node.js 24 · Standard library · Loopback only · Synthetic state
60-minute workshop + optional lead handover
Lead a client-delivery pod
Run a facilitated team rehearsal: receive a code candidate, challenge conflicting sources and defend a client-scope decision. Keep individual evidence, then rehearse an explicit lead handover when owners or permissions are missing.
Presentation guide
Rehearse the enterprise walkthrough
Walk a CTO through Claude Code, a first LangChain agent, LangGraph routing, MCP tool boundaries and NVIDIA systems, with exact production click paths.
The thinking behind the work
Engineering judgment comes first.
Explore the decisions behind useful agent systems, then bring an idea back to your next practice session.
Before you blame the model, inspect the contract
A composite failure scenario shows how an ambiguous tool schema can turn a capable model into an unreliable operator — and why a common protocol is plumbing, not proof of contract quality.
Read the essay MANIFESTO / 7 MIN READDesign for operators, not completion.
Watching an expert work is not the same as doing the work. LockedIn Labs is built around that difference — a graph instead of a catalog, proof-of-work instead of completion, and a defined cohort operating model that activates only when a cohort is contracted and staffed.
Read the essayWhat does a forward-deployed engineer practice?
A forward-deployed engineer works close to the people using a system. The work begins with understanding a workflow and agreeing what a useful change would do. It continues through implementation, evaluation, deployment planning and transfer to the team that will operate it.
For agentic AI, that includes deciding which tools an agent may call, what evidence supports its output, where a person must approve an action and how the workflow recovers when a tool or source fails. The exercises use synthetic administrative requests so you can practice those decisions without customer data.
The workbook connects six artifacts: a discovery brief, implementation record, service boundary, evaluation report, operator handoff and delivery defense. The client-delivery curriculum adds guided lessons and practice under existing Academy access.
Plan your learning.
Can I start without coding experience?
Yes. Begin with the learner start guide, sketch the request journey and try the discovery interview with a partner. The optional code exercises use Node.js 24; you can first work through the workbook as a tabletop exercise.
What is free, and what requires Academy access?
All guides in this library are free to read and download. The learning kit also includes an offline code starter and synthetic fixtures. Full guided lessons and review use existing Academy access.
How can I check my starting knowledge?
Use the free AI learning diagnostic to explore your learning needs, or try the public foundation practice. Treat these as learning inputs; they do not award an engineering qualification.
Can a team use these materials for a learning session?
Run the free sixty-minute pod-delivery workshop with five delivery roles, a shared code candidate and a changed client request. Each participant keeps their own handoff observations and next practice. The facilitator pack supports enterprise employee teams and FDE cohorts.