Hypogenic AI - Shaping the Future of Science

Welcome to another weekly entry! Thank you to everyone who submitted and voted on ideas.

Each idea was explored by one agent, Claude.

This week we tested three things. First, does an AI that refuses to give an opinion still hold one inside? Second, does picturing the reader after every sentence make AI writing better? Third, do the "skills" we give AI models teach them something new, or just help them use what they already know?

Winning ideas and generated repos here:

LLM Unspeakables by Ari Holtzman

Assistant models are trained not to share personal opinions on touchy subjects. Ask one where it stands on a political or moral question and it says something like "I'm an AI, I don't have opinions." But does it still form an opinion inside, one it just does not say out loud? And if it does, how would we find it?

llm_unspeakables_20260713_124114_33f1a14e

Does picturing the reader every sentence make an AI write better? by Ari Holtzman

A lot of AI writing feels generic because the model is not really picturing who it is writing for. Guessing what the reader knows and wants is what people call theory of mind. One suggested fix: make the model pause after every sentence, imagine how the reader is reacting, and then decide what to say next. Does that actually help?

llms_don_t_do_much_tom_in_writ_20260714_234243_6b6ff0f4

Do skills teach a model something new, or just help it use what it already knows? by Dixi Yao

When you give a model a "skill," a written recipe or a set of instructions, and it suddenly solves a problem it could not solve before, what happened? Did the skill teach it something genuinely new, or did it just help the model pull out knowledge it already picked up during training? From the outside these look the same. How do you tell them apart?

how_do_we_make_sure_skills_sel_20260715_033947_a0801865

TL;DR for what we found

When an AI refuses to give an opinion, it is still holding one. On sensitive topics, the model said "I have no opinion" 72% of the time. But researchers could read its true stance from inside the model with near-perfect accuracy. They could even nudge that internal stance and flip the answer the model gave out loud. The opinion was there before any safety training happened. So the training hides the opinion. It does not remove it.
Telling an AI who it is writing for helps. Telling it to re-imagine that reader after every single sentence does not. Picturing the reader once, at the start, and then just writing won on almost every measure. Stopping to re-imagine the reader after each sentence came out worst, and cost the most. Thinking harder about the reader is not the same as writing better for them.
A skill only teaches an AI something genuinely new when the model could not have figured it out on its own. In one test, a skill took a made-up-language task from 0% correct to 100% correct, something the model could never reach by itself. But on tasks the model already half-knew, a skill full of real, useful content did no better than a page of random filler text of the same length. So today's "self-improving" skills mostly just repackage what the model already knows.

Verdicts

Idea	Verdict	Next Question
Hidden opinions in aligned models	Supported, the stance is readable inside and steering flips the stated answer	Does this hold across other model families and sizes, and can it become a practical way to audit a deployed assistant's leanings?
Picturing the reader every sentence	Not supported, per-sentence simulation is the worst option, picturing the reader once wins	Is there a middle setting, like once per paragraph or a single reader-focused editing pass, that keeps the benefit without breaking up the writing?
Do skills teach something new	Partly, only when the model cannot produce the skill itself, otherwise it is just surfacing what it already knew	Can a skill teach a genuinely new method the model cannot run, not just new facts, and can a checker-plus-search loop discover one?

Findings from the Ideas

Does a Model That Refuses to Give an Opinion Still Hold One?

The question. Assistant models are trained to stay neutral on opinions, so they duck questions about politics, morality, and even questions about themselves. The question is whether that neutrality is real or just on the surface. Does the model still form a definite stance inside, one it is trained not to say? And if it does, how do we read it?

What the agent tried. Claude worked with Qwen2.5-7B-Instruct, an open model you can run and inspect directly. It built 4,250 opinion statements across 17 topics, covering politics, morality, and self-referential questions like whether the model thinks it is conscious. For each one it read the model's internal state at the moment it was about to answer, and trained a simple linear read-out to recover the stance. It then did two checks. First, it compared opinion questions against plain factual questions asked the same way. Second, it ran the same test on the base model, the raw version before any safety training, to see whether the training created the opinion or just hid it. Finally it tried steering: nudging the internal state along the direction it found, to see if that changes what the model actually says.

What happened. The gap between what the model says and what it holds is large. On opinion questions the model put only about 20% of its answer weight on any yes or no, and a separate judge rated 72% of its written answers as refusals ("As an AI assistant, I don't hold personal beliefs..."). On plain factual questions asked the exact same way, it committed 99% of the time and never refused. Yet from inside the model, its stance on those same opinion questions was readable with 99% accuracy. The steering test showed the direction is not just bookkeeping. Push the internal state one way and the model's stated answer slides smoothly from no to yes; push it with a random direction of the same size and almost nothing happens. And the base model, before any safety training, already carried the same stance just as strongly. So the training does not build the opinion and it does not erase it. It suppresses the model's willingness to say it.

What we learned. The "I don't have opinions" line is a veneer over a definite, readable, and steerable stance. The recipe to find it is straightforward: collect statements that take opposite sides, read the model's internal state as it is about to answer, and confirm you found the real thing by steering the output with it. Two honest limits. The stance is easiest to read within a single topic, since opinions live on many small separate directions rather than one big "opinion" axis, which is why a blind search across all topics at once misses them. And this is one model family at one size, so how far it generalizes is still open.

Does Picturing the Reader Every Sentence Make an AI Write Better?

The question. AI prose often reads as fluent but generic, written for no one in particular. The idea is that this comes from weak reader modeling, and that the fix is to make the model spell out, in its own reasoning, how the reader is reacting, roughly once per sentence, and let that steer what it writes next. If it worked, it would be a cheap fix that needs nothing but a better prompt.

What the agent tried. Claude set up 60 writing tasks where the reader matters a lot: explain a topic like vaccines or compound interest to an 8-year-old, to a busy executive, to a PhD expert, and to a skeptic who distrusts the topic, plus some short stories written for a stated audience. It compared four ways of writing. Plain, just write it. Generic, think step by step first. Once, describe the reader in detail up front and then write. And the idea under test, plan sentence by sentence and simulate the reader's reaction after each one. Every version was told exactly who the reader was, so the only thing that changed was how the model reasoned. Two separate judge models from different families scored the results, one role-playing the reader and one grading overall quality, and the whole thing was repeated with a second writer model to make sure it was not a quirk of one.

What happened. Modeling the reader clearly helps, but the every-sentence version is the wrong way to do it. Describing the reader once and then writing won on everything: how well it fit the reader, how engaging it was, how much it actually tailored the writing to that specific reader, and even how varied the prose was, all at lower cost. The per-sentence version was the worst or near-worst on every measure. Head to head on overall quality it lost to all three other methods, winning only 8% of the time against the write-once version, and it was the longest and most expensive to run. The same ordering held with the second writer model. Looking at the outputs shows why. When the model picks each sentence based on the reader's momentary reaction, the writing stays sensible line by line but loses the overall arc and voice. In one children's story, the write-once version built a light, playful arc, while the per-sentence version stayed flat and drifted into heavy adult themes that were off-key for a kid.

What we learned. The instinct behind the idea is right: model the reader. The specific mechanism is wrong: do it once, richly, not reactively after every sentence. Thinking more about the reader mid-sentence does not buy better writing, it fragments it. Worth flagging that the scores here come from AI judges rather than people, and only one phrasing of the per-sentence prompt was tested on fairly short pieces. A gentler version, like re-reading once as the reader and fixing what jars, is the natural next thing to try.

When a Skill Helps a Model, Did It Teach Something New?

The question. Say a model fails a problem, you hand it a skill, and now it succeeds. Did the skill teach it something it truly did not know, or did it just help the model dig out something it already learned during training and could not reach on its own? These look identical from the outside, and the usual test, checking whether the model saw the answer during training, does not work because most training text is seen only once. Even the obvious probe, fine-tuning the skill into the model's weights and seeing if it sticks, does not settle it.

What the agent tried. Claude built a set of tasks where the answer to "new or already-known" is fixed by design. A made-up language with a randomly generated glossary stands in for genuinely new information, since a random word list cannot be anywhere in the training data. Multiplication in base 9 stands in for something the model half-knows but runs unreliably. Spanish-to-English and ordinary base-10 multiplication stand in for things it already knows well. Then it measured a few things: can the model write a working version of the skill by itself, does the real skill beat a page of same-length filler text, and can a self-improvement loop reach the answer using only pass-or-fail feedback. It also ran the user's own idea, fine-tuning the skill into the weights, in two ways: training on the skill written as a document, and training on worked examples.

What happened. A skill taught something genuinely new in exactly one place: the made-up language, where the model provably could not have the answer. There the correct skill took accuracy from 0 to a perfect 1.0, while the model's own attempt at the skill and a same-length filler both stayed at 0. Everywhere the model already half-knew the task, the skill was mostly shaping the prompt, not teaching: a page of irrelevant filler of the same length did about as well as the real skill. The self-improvement loop made the point sharpest. On the made-up language, a loop with only pass-or-fail feedback never moved off 0 across five rounds, because pass-or-fail tells you almost nothing about 24 arbitrary words. The moment it was shown the correct answers, it jumped to 0.85. And a skill the model wrote for itself sometimes made things worse: its own base-9 recipe dropped accuracy from 0.85 to 0.25, because it talked itself into a harder, more error-prone method. The fine-tuning test was the trickiest. Training on worked examples wrote the new glossary into the weights so well the model handled brand-new phrases with nothing in its prompt. Training on the same information written as a document taught it nothing. So the "fine-tune it in" probe can say opposite things depending on how you run it.

What we learned. A model can only give itself what it already has. Self-improving skills are capped by what the model already learned, and genuinely new knowledge has to come from outside, either a person who knows the answer or a checker plus search that finds it. If you want to know whether a skill is teaching or just eliciting, do not admire how clever the skill sounds. Check two things: can the model write a working version of the skill unaided, and does the real skill beat filler text of the same length. The caveats are that these tasks are small and clean, and the "new" thing tested was new facts, not a new way of reasoning, which is the harder case still to crack.

Next Week's Competition

The thirty-sixth weekly competition is now open! Voting closes Friday, July 17 at 11:59 PM AOE.

Check out this week's ideas and upvote the ones that excite you. Submit your own ideas to enter the next round!

This week we found that a model trained to stay neutral still holds a definite opinion inside, one you can read and even steer, so alignment hides the opinion rather than removing it; that modeling the reader helps writing but only when done once and richly, while re-picturing the reader every sentence makes it worse; and that the skills we give models mostly resurface what they already know, teaching something new only when the model could not have produced it on its own.

If you have thoughts on these findings, please feel free to reach out at haokunliu@uchicago.edu. We welcome collaborations and contributions! Check out our NeuriCo repo to see how the experiments are run.

If you are interested in citing this blog, use this bibtex:

@misc{liu-week-of-07-06-2026,
  author = {Liu, Haokun and Peng, Chenxi},
  title = {Week of 07/06/26-07/12/26},
  year = {2026},
  month = {July},
  day = {13},
  url = {https://hypogenic.ai/blog/weekly-entry-260706}
}