Frequently Asked Questions About Deming Live-Build Learn-As-You-Go Method
22 answers covering everything from basics to advanced usage.
// Basics
What exactly is a warm-up read and why does it matter?
A warm-up read is a short one-to-three-page passage from a primary technical source—a guide, RFC, or spec, not a tutorial—read at the start of a session. It matters because it activates new vocabulary and sets a learning tone before you touch code. Skipping it means your later AI solidification conversations are less productive because you lack the terms to describe what confuses you.
What counts as a 'primary source' for the warm-up read?
Primary sources are original technical documents: official framework docs, RFCs, protocol specs, or authoritative technical guides. They're distinct from tutorials, YouTube walkthroughs, or blog how-tos, which are secondary interpretations. The goal is exposure to precise, canonical vocabulary and structure that you can then solidify through conversation rather than pre-digested step lists.
What is demultiplexing in the context of this method?
Demultiplexing is the per-layer process where each protocol layer reads a header field identifying the next protocol and decides where to forward the payload. Each layer does this independently rather than interpreting the whole packet at once. It's introduced as the precise term you arrive at during AI solidification of the onion/Russian doll encapsulation model.
What are 'appearances' and 'hot streak' in the example project?
Appearances is a custom metric tracking how many times a user has appeared across pipeline runs—a signal of consistent performance versus a one-hit wonder. Hot streak is a planned follow-on feature tracking consecutive back-to-back appearances, displayed as a flame emoji with a count that resets if the streak breaks. They illustrate how one feature naturally suggests the next logical sub-feature.
// How To
How do I know when to stop an AI solidification conversation?
Stop when the AI confirms your mental model is solid—signals like 'you have the structure exactly right now'—and you can restate the concept accurately in your own words. Do not keep going until every edge case is exhausted; that's overkill. The purpose is a correct mental model, not encyclopedic completeness. Over-deep conversations waste session time better spent building.
How do I set up both servers for a Deming session?
Spin up your backend and frontend dev servers at the start of the session—for example Uvicorn with reload for a Python backend and npm run dev for a React frontend. Let any background jobs or cron scripts run in parallel so you can inspect their output mid-session without interrupting coding flow. This keeps you in a live-feedback loop the whole time.
How do I identify the one focused feature for a session?
State it explicitly and narrowly: one component, one endpoint, or one UI section. Write it down. If a new feature idea surfaces mid-session, note it in a defer list and keep going on the current feature unless it's complete or truly blocked. Naming a single target prevents scope drift and preserves momentum.
How should I ask AI a question when I'm stuck?
Ask a narrow, specific question about the exact blank you hit—for example, 'how do I attach an onClick that navigates on a button in React?'—rather than requesting a whole feature. Then filter the answer, type only the relevant part yourself, and don't paste blocks wholesale. This keeps AI as an unsticking tool, not a code generator.
How do I set design constraints before styling?
State your constraints out loud or in writing before opening any reference: for example, 'clean, no cringe transitions, Apple/Google approach.' Then use those constraints as a filter for every option, rejecting anything that violates them even if it looks impressive alone. Prefer rounded-large corners over pills or full circles, and subtle active-state feedback over flashy animation.
// Troubleshooting
My appearances count is always 1—is this a bug?
Not necessarily. If only one pipeline run has completed, every record will show appearances of 1, which is expected behavior, not a logic error. This is why the method insists you check the live database state before building. Once a second run completes, query for records with appearances greater than 1 to properly validate the incrementing logic.
I keep context-switching mid-session—how do I stop?
Adopt the defer discipline: when a new feature idea surfaces, write it in a note list and return to your named session feature immediately. Only switch if the current feature is genuinely complete or truly blocked. Context-switching kills momentum and leaves half-finished states scattered across your codebase, which is harder to recover from than the appeal of the shiny new idea suggests.
My UI looks cluttered and users disengage—what's wrong?
You're likely defaulting to the Microsoft approach—dense and cluttered—instead of the Apple/Google approach of thought-out spacing, clean layout, and appropriately sized elements. Users disengage from dense data UIs the same way they want to crumple a tax form. Fix it by adding intentional whitespace, sizing elements deliberately, and removing any transitions or animations that don't serve comprehension.
I finished a tutorial but still can't build alone—can this help?
Yes, that's exactly the tutorial-hell problem this method targets. By reading primary sources, solidifying concepts through active recall with AI, and hand-typing 95%+ of your code, you shift from passive copying to genuine understanding. The friction of typing and the discipline of restating concepts in your own words are what convert following steps into independent building capability.
// Comparisons
How does this method compare to pure AI code generation?
Pure AI code generation maximizes short-term output but leaves you with code you can't reason about or debug. The Deming method deliberately caps AI to unsticking and concept-solidification, trading raw speed for durable comprehension. You ship fewer lines per hour but retain the knowledge and can maintain the codebase. It's optimized for learning-while-building, not for shipping throwaway prototypes fastest.
How does 'Roll With the Punches' differ from agile sprint planning?
Roll With the Punches is a freestyle solo philosophy—think about what you want, hit the next roadblock, figure out how to cross it, and add features organically—favoring momentum over planning paralysis. Agile sprints rely on pre-committed backlogs, tickets, and team coordination. Deming's approach suits solo learners who'd stall under rigid checklists; it's not a substitute for structured team planning.
How is this different from just reading docs and coding?
The difference is structure and sequencing: a deliberate warm-up read, a bounded AI solidification loop with a clear stop signal, a live-data check before building, a single named feature, and explicit design constraints. Ad hoc reading-then-coding lacks the vocabulary activation, the mental-model confirmation, and the anti-bloat discipline that keep this method both educational and productive within one session.
Is AI solidification better than just asking AI to explain a concept?
Yes, because solidification is iterative and learner-driven: you propose your own analogy first, then the AI corrects it until confirmed accurate. A one-shot explanation lets you nod along without testing your understanding. Building and defending your own model with analogies like Russian dolls forces active recall, which produces a mental model you can actually restate and apply.
// Advanced
How do I decide which sub-feature to add next without bloating?
After each feature ships, ask what single addition would genuinely round it out without adding scope. Look for natural extensions—an appearances badge naturally suggests a hot streak indicator. Evaluate each candidate against the no-feature-bloat principle: does it serve the core feature or is it scope creep? Add only if it deepens the existing feature rather than starting a new one.
Can I use this method for a backend-only or API project?
Yes. The core loop—warm-up read, AI solidification, live-data check, one focused feature, hand-typed code—applies fully to backend work, where the 'Type It Yourself' principle is emphasized most. The Apple/Google cleanliness principle simply becomes less relevant without a UI, though clean API design and response shaping are its analog. Everything else transfers directly.
How do I maintain continuity across multiple sessions?
Close each session with a live demo of the app's current state, note what styling or features still need work, and explicitly name the next session's target feature. This closing scope note creates continuity and prevents scope drift, so you resume with a clear single target rather than rediscovering where you left off and being tempted into new tangents.
When is this method a poor fit?
It's a poor fit for team projects with rigid tickets and dependencies, deadline-driven delivery where learning is secondary, or throwaway prototypes where retention doesn't matter. The freestyle 'Roll With the Punches' approach and deliberate hand-typing slow raw output, so if pure speed or strict spec conformance dominates, a checklist-driven or AI-heavy workflow may serve better.
How deep should the warm-up read go in unfamiliar territory?
Keep it to one short chapter or passage of one to three pages, even in unfamiliar territory. The goal is vocabulary activation, not mastery—you'll deepen understanding through the AI solidification step. Reading too much upfront delays building and can overwhelm you before you've anchored terms through conversation and code. Note unfamiliar terms as solidification targets and move on.