{"id":8618,"date":"2026-02-19T10:07:25","date_gmt":"2026-02-19T15:07:25","guid":{"rendered":"https:\/\/frontendmasters.com\/blog\/?p=8618"},"modified":"2026-02-19T10:07:26","modified_gmt":"2026-02-19T15:07:26","slug":"ai-hates-ambiguity-a-guide-to-probability","status":"publish","type":"post","link":"https:\/\/frontendmasters.com\/blog\/ai-hates-ambiguity-a-guide-to-probability\/","title":{"rendered":"AI Hates Ambiguity: A Guide to Probability"},"content":{"rendered":"\n

We often treat Large Language Models (LLMs) like magic chat boxes. Brilliant colleagues ever awaiting our next question. This isn’t terribly far off these days. We’re certainly past the stochastic parrot<\/a> phase. As with a human colleague, the more specific we are in our questions and requests, the more useful the conversation will be.<\/p>\n\n\n\n

Every time you send a prompt, you are defining a probability distribution<\/strong>. You provide the context (the input tokens), and the model calculates the most likely\/useful next set of output tokens based on the weights in its neural network.<\/p>\n\n\n\n

When you constrain<\/strong> that distribution effectively, the result feels magical: precise, production-ready code. But when we force the AI to guess<\/strong> our intent \u2014 because we were vague, assumed it “knew the context,” or skipped the edge cases \u2014 we widen the continuation space<\/strong>. We force the model to choose from a massive array of potential answers, most of which are mediocre.<\/p>\n\n\n\n

In engineering, we often call bogus results “hallucinations,” but in practice, they’re\u00a0probability drift<\/strong>\u00a0caused by<\/span> unclear guidance. It happens because we failed to anchor the model\u2019s completion path to a specific, high-quality distribution.<\/p>\n\n\n\n

To fix this, we need to stop “chatting” and start architecting<\/strong>. Let\u2019s look at exactly what happens when we ignore the mechanism.<\/p>\n\n\n\n

The “Hostile” Prompt<\/h2>\n\n\n\n

I call the prompt below “hostile” because it ignores the model’s statistical reality. It treats the AI like a mind reader rather than a pattern matcher.<\/p>\n\n\n\n

The Prompt:<\/p>\n\n\n\n

\n

Write a function to fetch user data from an API and save it to state.<\/p>\n<\/blockquote>\n\n\n\n

In this simple request, there are three distinct specification gaps <\/strong>that will break your production app:<\/p>\n\n\n\n

    \n
  1. The Tutorial Bias: <\/strong>The model\u2019s training data is dominated by simple tutorials where APIs never fail. Without constraints, it defaults to this “Happy Path” because it is statistically the most common pattern.<\/li>\n\n\n\n
  2. Type Blindness: <\/strong>It generates generic JavaScript instead of strict TypeScript because the constraints weren’t negotiated.<\/li>\n\n\n\n
  3. The State Gap: <\/strong>It writes the fetch logic immediately (prediction) without handling intermediate states (loading\/error), causing UI flashes.<\/li>\n<\/ol>\n\n\n\n

    \ud83d\udee0 The “Before” Output (The Drift)<\/h2>\n\n\n
    \/\/ The AI's \"Default\" Response<\/span>\nuseEffect(()<\/span> =><\/span> {\n  fetch('\/api\/users'<\/span>)\n    .then(res<\/span> =><\/span> res.json())\n    .then(data<\/span> =><\/span> setUsers(data)); \/\/ Risky: No loading state, no<\/span>\nerror handling, race conditions.\n  }, []);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    This code isn’t “broken”, it’s just optimized for brevity, not production. It lacks cancellation, error boundaries, and loading indicators.<\/p>\n\n\n\n
    The Theory (Why This Happens)<\/h3>\n\n\n\n
    Why did the AI give us such mediocre code? It wasn’t because it’s “dumb.” It was a failure of Contextual Anchoring<\/strong>.<\/p>\n\n\n\n
    To fix this, we need to respect the architecture. The model operates on a complex Transformer architecture, but the behavior can be summarized as:<\/p>\n\n\n\n
      \n
    1. Ingest: <\/strong>It maps your input tokens into a high-dimensional vector space.<\/li>\n\n\n\n
    2. Attention: <\/strong>It calculates “attention weights” \u2014 deciding which previous tokens are most relevant to predicting the next one.<\/li>\n\n\n\n
    3. Sampling: <\/strong>It selects the next token based on the calculated probabilities.<\/li>\n<\/ol>\n\n\n\n
      The Limitation: Attention Decay<\/h3>\n\n\n\n
      Critically, the model’s attention mechanism is finite. It suffers from Token Locality<\/strong>. As a conversation grows longer, the influence of earlier tokens (like your initial instructions) can dilute.<\/p>\n\n\n\n
      If you paste a 500-line file and ask for a refactor at the bottom, the model is statistically less likely to “attend” to the specific style guide you pasted at the very top. To combat this, effective engineers re-inject critical constraints (like “Remember to use strict TypeScript”) closer to the generation point.<\/p>\n\n\n\n
      The “Likelihood” Mistake<\/h3>\n\n\n\n
      In our hostile prompt, we ignored this mechanism. We provided a short, vague input, which left the “search space” for the answer too wide. When you say “Write a function”, the model maximizes likelihood by choosing the path of least resistance: the tutorial snippet. Every time we leave a constraint undefined, the model fills the gap with the most common pattern in its dataset.<\/p>\n\n\n\n
      We need to move from Implied Intent <\/strong>(hoping it gets it) to Explicit Constraint <\/strong>(forcing the distribution toward quality).<\/p>\n\n\n\n
      Solutions<\/h2>\n\n\n\n
      <\/p>\n\n\n\n
      We are going to make three specific negotiations with the AI to ensure stability.<\/p>\n\n\n\n
        \n
      1. The Persona Negotiation (System Context)<\/strong>: The AI isn’t “wrong” when it gives you a simple script; it is fulfilling the pattern of a “helpful assistant”. We need to narrow the distribution to “Senior Engineering.” The fix here is to use a system prompt of sorts, or global context. Something like a claude.md<\/code> file or agents.md<\/code> file. It could have context like this: You are a Senior Frontend Engineer who prioritizes defensive coding. You reject “happy path” code. You always implement error handling, type safety, and cleanup functions.<\/em><\/li>\n\n\n\n
      2. The Format Negotiation (Output Constraints): <\/strong>Just as the browser struggles<\/a> when elements load out of order, the AI struggles when it mixes conversational filler with code. We need to force a strict structure. The fix here is to include extra information in our prompts, to the tune of: Return only the code block. Do not add introductory text. Ensure the code is strictly typed TypeScript.<\/em><\/li>\n\n\n\n
      3. The Logic Anchor (Chain of Thought): <\/strong>This is the most critical technique. Normally, the AI predicts code token-by-token immediately. This is like coding without a plan. By asking for a “plan” first, we force the model to generate tokens that bias the<\/strong> attention weights <\/strong>for the subsequent code. If the model writes “I must handle the race condition before <\/em>it writes the code, the probability of it actually writing AbortController skyrockets. The fix here might be prompting to ask for a plan first, like: <\/strong>Before generating the code, list the 3 most likely failure modes for this feature (e.g., race conditions, network errors) and explain how you will prevent them.<\/em><\/li>\n<\/ol>\n\n\n\n
        Phase 4: The “Stable” Interaction<\/h3>\n\n\n\n
        Here is a prompt asking for the same thing we did originally, but negotiated correctly.<\/p>\n\n\n\n
        The Orchestrated Prompt:<\/p>\n\n\n\n
        \n
        Write a useUsers hook.<\/p>\n\n\n\n
          \n
        1. Use AbortController to handle unmounting (Race Condition).<\/li>\n\n\n\n
        2. Strictly type the response.<\/li>\n\n\n\n
        3. Return a tuple: [data, loading, error]<\/li>\n<\/ol>\n<\/blockquote>\n\n\n\n

          \ud83d\udee0 The “After” Output<\/strong><\/h3>\n\n\n
          \/\/ The AI's \"Production\" Response<\/span>\nconst<\/span> useUsers = (): [User[], boolean, Error<\/span> | null<\/span>] => {\n  const<\/span> [data, setData] = useState<User[]>([]);\n  const<\/span> [loading, setLoading] = useState<boolean>(false<\/span>);\n  const<\/span> [error, setError] = useState<Error<\/span> | null<\/span>>(null<\/span>);\n\n  useEffect(()<\/span> =><\/span> {\n    const<\/span> controller = new<\/span> AbortController();\n    setLoading(true<\/span>);\n    setError(null<\/span>); \/\/ Reset error state on new fetch<\/span>\n    const<\/span> fetchData = async<\/span> () => {\n      try<\/span> {\n        const<\/span> res = await<\/span> fetch(\"\/api\/users\"<\/span>, {\n          signal<\/span>: controller.signal,\n        });\n        if<\/span> (!res.ok) throw<\/span> new<\/span> Error<\/span>(`Error: ${res.status}<\/span>`<\/span>);\n        const<\/span> result = await<\/span> res.json();\n        setData(result);\n      } catch<\/span> (err) {\n        if<\/span> (err.name !== \"AbortError\"<\/span>) {\n          setError(err as<\/span> Error<\/span>);\n        }\n      } finally<\/span> {\n        if<\/span> (!controller.signal.aborted) {\n          setLoading(false<\/span>); \/\/ Guard against unmounted state updates<\/span>\n        }\n      }\n    };\n    fetchData();\n    return<\/span> ()<\/span> =><\/span> controller.abort(); \/\/ Cleanup negotiated.<\/span>\n  }, []);\n};\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          Notice the difference. It handles the loading state. It resets errors on retry. It cleans up after itself. It feels like it was written by a human engineer because we gave the model the constraints it needed before <\/em>it started predicting.<\/p>\n\n\n\n
          A Note on Limitations<\/h3>\n\n\n\n
          It is important to acknowledge that prompt engineering is not magic. Even the most perfectly constrained prompt cannot force a model to solve a problem that exceeds its training data or reasoning capabilities. If the model simply doesn’t know a library, no amount of “persona setting” will teach it.<\/p>\n\n\n\n
          However, for the vast majority of daily engineering tasks, the failure point is not the model’s capability \u2014 it is the prompt’s ambiguity.<\/p>\n\n\n\n
          Conclusion<\/h2>\n\n\n\n
          Prompt Engineering is not about “tricking” the machine; it is about constraining <\/strong>the machine. Every bug, every generic tutorial script, and every “hallucination” is a signal that the continuation space was too wide. We failed to give the AI the context it needed to converge on the right answer.<\/p>\n\n\n\n
          Stop hoping for good code. Start architecting <\/strong>for it.<\/p>\n","protected":false},"excerpt":{"rendered":"
          The more effort you put in to what you put in, the higher quality you’re going to get out.<\/p>\n","protected":false},"author":43,"featured_media":8647,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"sig_custom_text":"","sig_image_type":"featured-image","sig_custom_image":0,"sig_is_disabled":false,"inline_featured_image":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[1],"tags":[104],"class_list":["post-8618","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog-post","tag-ai"],"acf":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/frontendmasters.com\/blog\/wp-content\/uploads\/2026\/02\/architect.jpg?fit=2000%2C1200&ssl=1","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/posts\/8618","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/comments?post=8618"}],"version-history":[{"count":21,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/posts\/8618\/revisions"}],"predecessor-version":[{"id":8653,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/posts\/8618\/revisions\/8653"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/media\/8647"}],"wp:attachment":[{"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/media?parent=8618"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/categories?post=8618"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/frontendmasters.com\/blog\/wp-json\/wp\/v2\/tags?post=8618"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}