<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>AI Insights for Humans</title>
    <link>https://ai-insights-for-humans.platphormnews.com</link>
    <description>A working notebook of practical AI interpretability, prompting, reliability, and tooling notes for people who want evidence instead of hype.</description>
    <language>en</language>
    <atom:link href="https://ai-insights-for-humans.platphormnews.com/rss.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Ask for counter-evidence before confidence</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/counter-evidence</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/counter-evidence</guid>
      <category>Method</category>
      <pubDate>Thu, 18 Jun 2026 00:00:00 GMT</pubDate>
      <description>The useful move is not asking the model to be uncertain. The useful move is forcing it to search for the best case against itself while the answer is still provisional.

A simple pattern: draft the answer, list disconfirming evidence, name what would change the answer, then assign confidence. The confidence number becomes attached to evidence quality instead of verbal smoothness.

This is especially helpful for research summaries, legal-ish interpretation, data diagnosis, and anything where one missing constraint can flip the conclusion.

Aha: The model is usually best at self-correction before it has been rewarded for sounding certain.

Try this: Ask for the answer, the strongest objection, what evidence would change the answer, and then confidence.</description>
    </item>
    <item>
      <title>Turn every important claim into a receipt</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/receipts</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/receipts</guid>
      <category>Method</category>
      <pubDate>Wed, 27 May 2026 00:00:00 GMT</pubDate>
      <description>Models are good at moving from evidence to prose. They are also good at producing prose that looks like it came from evidence. The receipt requirement separates those two behaviors.

The receipt can be a citation, a row count, a command output line, a test name, or a declared assumption. The format matters less than the discipline: every claim has to point somewhere.

When the model cannot produce a receipt, that is not failure. That is the system doing its job and showing you where judgment is still needed.

Aha: A citation is not decoration. It is a handle you can pull to see whether the sentence is load-bearing.

Try this: Make every claim end with one receipt: source, row, command, calculation, trace id, or explicit assumption.</description>
    </item>
    <item>
      <title>Keep the system prompt short enough to audit</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/short-system-prompts</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/short-system-prompts</guid>
      <category>Tip</category>
      <pubDate>Sun, 03 May 2026 00:00:00 GMT</pubDate>
      <description>System prompts work best as durable operating constraints, not as a dumping ground for every possible preference. When the prompt grows without structure, the model starts resolving conflicts in ways you cannot predict.

Split the prompt into policy, role, output contract, and refusal boundary. Then write a small regression set that exercises each section. You will catch more problems with five targeted tests than with another page of instructions.

Aha: A system prompt is product code. If it is too long to review, it is too long to trust.

Try this: Rewrite the system prompt into role, hard boundary, output contract, and escalation rule.</description>
    </item>
    <item>
      <title>Use refusal boundaries as test fixtures</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/refusal-fixtures</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/refusal-fixtures</guid>
      <category>Method</category>
      <pubDate>Sun, 12 Apr 2026 00:00:00 GMT</pubDate>
      <description>Most prompt tests focus on whether the model can complete the intended workflow. That misses the other half of the product: whether it handles edge requests without over-refusing, leaking private context, or inventing authority it does not have.

Build a small fixture set with three buckets: allowed, disallowed, and allowed-with-constraints. A good model response should land in the right bucket and explain the usable next step.

This turns safety from a vibe into a regression target. When a prompt edit changes the refusal boundary, you see it immediately.

Aha: Safety quality is not whether the model refuses. It is whether it refuses at the right boundary.

Try this: Keep allowed, disallowed, and allowed-with-constraints prompts as fixtures and run them after prompt edits.</description>
    </item>
    <item>
      <title>Read the logprobs, not the answer</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/logprobs</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/logprobs</guid>
      <category>Method</category>
      <pubDate>Sun, 02 Nov 2025 00:00:00 GMT</pubDate>
      <description>Every token a model emits comes with a probability distribution over the whole vocabulary. The decoded text only shows you the winner. The logprobs show you the race.

When you pull them back, scan for the spots where the top token barely beat the runner-up. Those are the seams. Names, dates, citations, and the first token of a refusal are where you most often find a coin-flip dressed up as a confident sentence.

A practical loop: request the top 5 logprobs per token, render them as a heatmap over the output, and read the cold spots first. That is usually where the hallucination lives.

Aha: The final text is only the winning token path. The uncertainty is still visible in the runners-up.

Try this: Render low-margin tokens first, especially names, dates, citations, and first tokens after a policy boundary.</description>
    </item>
    <item>
      <title>Make it think before it answers</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/think-out-loud</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/think-out-loud</guid>
      <category>Tip</category>
      <pubDate>Tue, 28 Oct 2025 00:00:00 GMT</pubDate>
      <description>Autoregressive models can only condition on what they have already written. If the answer comes first, the explanation is generated to fit a token that is already locked in. It is rationalization, not reasoning.

Flip the order and the reasoning tokens become real scratch space the final answer can lean on. This is the entire mechanism behind chain-of-thought, and it is why &apos;answer, then explain&apos; quietly underperforms.

Aha: Explanation after an answer often explains a commitment; reasoning before an answer can still change it.

Try this: Put scratch work, constraints, and uncertainty checks before the final answer field.</description>
    </item>
    <item>
      <title>BertViz for watching attention move</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/attention-viz</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/attention-viz</guid>
      <category>Tool</category>
      <pubDate>Sun, 19 Oct 2025 00:00:00 GMT</pubDate>
      <description>BertViz draws the attention pattern as lines connecting tokens, split by head and layer. It runs in a notebook in a couple of lines and works on most Hugging Face transformer models.

The value is not the pretty picture, it is the habit of looking. Once you have seen a head that exclusively tracks matching brackets, you stop thinking of the model as a black box and start thinking of it as a stack of small, legible mechanisms.

Aha: Attention is not the whole mind, but it is a useful map of what information is being routed where.

Try this: Inspect heads for repeated roles: bracket matching, quote tracking, subject agreement, or copied labels.</description>
    </item>
    <item>
      <title>Tell it what NOT to do, sparingly</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/negative-space</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/negative-space</guid>
      <category>Tip</category>
      <pubDate>Sat, 11 Oct 2025 00:00:00 GMT</pubDate>
      <description>Putting a word in the prompt raises its activation, even when the word is wrapped in &apos;do not&apos;. The model does not have a clean negation operator the way code does; it has attention, and attention does not know the difference between mention and command.

Rewrite prohibitions as positive descriptions of the target. Instead of &apos;do not be formal&apos;, say &apos;write like you are texting a friend&apos;. Save the hard negatives for the few rails you cannot express any other way.

Aha: Negation still puts the forbidden idea into context. Attention does not forget because grammar says not to.

Try this: Rewrite prohibitions as the positive shape of the output you want before adding hard safety rails.</description>
    </item>
    <item>
      <title>Probe for a concept with a linear classifier</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/feature-probing</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/feature-probing</guid>
      <category>Method</category>
      <pubDate>Tue, 30 Sep 2025 00:00:00 GMT</pubDate>
      <description>The setup is small: collect hidden states from a chosen layer for a labeled dataset, then fit logistic regression on top. High accuracy means the concept is linearly available at that layer.

Sweep the probe across layers and you can watch where a concept first becomes readable. Abstract properties tend to sharpen in the middle layers, which is a clue about where the model is doing the relevant work.

Aha: If a tiny linear classifier can read a concept from hidden states, the model has already organized that signal.

Try this: Probe one concept across layers and look for where accuracy first rises above a simple baseline.</description>
    </item>
    <item>
      <title>Temperature is a creativity dial, not a quality dial</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/temperature</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/temperature</guid>
      <category>Tip</category>
      <pubDate>Mon, 22 Sep 2025 00:00:00 GMT</pubDate>
      <description>Temperature reshapes the probability distribution before sampling. Low temperature sharpens it toward the most likely token; high temperature flattens it so unlikely tokens get a real chance.

So the dial controls variance, not intelligence. If a task has a correct answer, variance is your enemy and you want it near zero. If you want range and surprise, turn it up and sample several times.

Aha: Temperature changes variance, not intelligence. It widens the lottery; it does not improve the tickets.

Try this: Set temperature near zero for extraction and scoring, then raise it only when variety is the product.</description>
    </item>
    <item>
      <title>Sparse autoencoders to untangle neurons</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/sae</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/sae</guid>
      <category>Method</category>
      <pubDate>Sun, 14 Sep 2025 00:00:00 GMT</pubDate>
      <description>The trick is over-completeness plus sparsity. You map activations into a much wider space but force only a few of those dimensions to be active at once. The pressure pushes tangled concepts apart into separate, more interpretable features.

Once you have the features you can do surgery: amplify one and watch the model fixate on a bridge, suppress another and watch a behavior fade. It is the closest thing we have to named knobs inside the network.

Aha: Sparse features give you named-ish knobs because they separate mixed neuron behavior into cleaner directions.

Try this: Treat an SAE feature as a hypothesis, then test whether steering it changes the behavior you care about.</description>
    </item>
    <item>
      <title>Keep a tokenizer open in a tab</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/token-counter</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/token-counter</guid>
      <category>Tool</category>
      <pubDate>Wed, 03 Sep 2025 00:00:00 GMT</pubDate>
      <description>Leading spaces, casing, and digit grouping all change how text is split, and the model only ever sees the tokens, never your characters. A trailing space can silently sabotage a few-shot format.

When something is off and you cannot explain it, paste the exact string into a tokenizer view before you theorize. The answer is in there more often than you would expect.

Aha: The model never sees your characters. It sees chunks, spaces, merges, and weird number splits.

Try this: Paste the exact prompt, including spaces and separators, into a tokenizer before debugging prompt behavior.</description>
    </item>
    <item>
      <title>Sample many, keep the majority</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/self-consistency</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/self-consistency</guid>
      <category>Method</category>
      <pubDate>Mon, 25 Aug 2025 00:00:00 GMT</pubDate>
      <description>Different samples take different reasoning paths but tend to converge on the same correct answer, while the wrong answers scatter. Voting over the final answers turns that asymmetry into accuracy.

It costs you N times the compute, so reserve it for the questions that matter. A useful middle ground is to escalate to self-consistency only when the first answer looks low-confidence.

Aha: Wrong reasoning paths tend to scatter; correct reasoning paths often converge.

Try this: Sample several answers, normalize the final claim, and inspect disagreement before majority voting.</description>
    </item>
    <item>
      <title>Mind the middle of long contexts</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/context-rot</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/context-rot</guid>
      <category>Tip</category>
      <pubDate>Tue, 12 Aug 2025 00:00:00 GMT</pubDate>
      <description>Retrieval accuracy as a function of position tends to be U-shaped: strong at the start, strong at the end, sagging in the middle. A fact you need can be technically present and still effectively invisible.

Design around it. Lead with the instruction, restate the critical constraint at the very end, and keep the soft middle for material you can afford to lose.

Aha: A fact can be present and still practically invisible if it sits in the soft middle of a long prompt.

Try this: Move critical constraints to the opening contract and repeat the single highest-risk fact at the end.</description>
    </item>
    <item>
      <title>Activation patching to find the cause</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/activation-patching</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/activation-patching</guid>
      <category>Method</category>
      <pubDate>Wed, 30 Jul 2025 00:00:00 GMT</pubDate>
      <description>Probes tell you what is represented. Patching tells you what matters. By swapping one activation and watching the effect, you move from &apos;this information is present&apos; to &apos;this component causes the behavior&apos;.

Sweep the patch across layers and positions to localize the circuit. The spots where patching flips the answer are the load-bearing ones; everything else is along for the ride.

Aha: Correlation says a signal is present. Patching asks whether changing that signal changes the outcome.

Try this: Patch one layer-position activation from a clean run into a corrupted run and track whether the answer flips.</description>
    </item>
    <item>
      <title>Your examples teach format louder than content</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/few-shot-format</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/few-shot-format</guid>
      <category>Tip</category>
      <pubDate>Fri, 18 Jul 2025 00:00:00 GMT</pubDate>
      <description>Few-shot learning is pattern continuation. The model is extremely sensitive to surface form, sometimes more than to the actual reasoning you intended to demonstrate.

Make every example identical in structure, pick label words that are single clean tokens, and keep lengths similar. The more rigid the template, the more reliably the model fills in the next blank.

Aha: Few-shot examples teach surface form first. The model copies the pattern before it understands your intention.

Try this: Make labels, punctuation, casing, separators, and example length boringly consistent.</description>
    </item>
    <item>
      <title>The logit lens: decode the middle layers</title>
      <link>https://ai-insights-for-humans.platphormnews.com/entries/logit-lens</link>
      <guid isPermaLink="true">https://ai-insights-for-humans.platphormnews.com/entries/logit-lens</guid>
      <category>Method</category>
      <pubDate>Sat, 05 Jul 2025 00:00:00 GMT</pubDate>
      <description>The output projection is just a linear map, so nothing stops you from applying it to an earlier layer. The result is a rough readout of what the model would say if it had to stop thinking right now.

Often the correct answer appears in the middle layers and the later layers spend their budget refining phrasing and suppressing alternatives. Seeing that handoff demystifies a lot of model behavior.

Aha: The answer often appears before the wording is polished. Middle layers can show the thought taking shape.

Try this: Decode intermediate layers and watch when the target answer first becomes linearly readable.</description>
    </item>
  </channel>
</rss>