The Fallacy of "Humanising" LLM Outputs

By Kuber Mehta (Rewritten)

When tracking the evolution of AI sentiment, I usually look toward Hacker News, viral GitHub repos, and X. Lately, a specific trend has emerged: users are adding "skills" to their agents, such as instructions to speak normally "Talk to me like I have ADHD" or mandates to use ASD-STE100 (Simplified Technical English).

While I get why people do this—LLM verbosity is annoying—I believe that "humanising" the model's core output is the wrong abstraction.

The Bandwidth Problem

The fundamental issue is that these stylistic constraints aren't applied after the logic is complete; they are integrated into the work. When you demand short sentences and no jargon, you are forcing the model to compress its reasoning into a low-bandwidth format.

Mathematically, we can view this as a loss of information: $I_{output} \ll I_{internal\_state}$

Because the output still "sounds" polished, you likely won't notice the critical details that were discarded during this forced compression.

The Agent Degradation Loop

This becomes catastrophic when agents communicate with other agents. If a sub-agent summarizes a bug for a parent agent, and that parent agent summarizes it again for the user, the data degrades at every step.

Comparison: What we get vs. What we need

"Human prose is an expert at smoothing over the jagged edges of failure."

When an agent is struggling—whether due to token window limits or conflicting evidence—human-like prose hides those "ugly" failures. I would much rather see a raw, confusing stack trace than a polite sentence that masks a hallucination.

The Engineering Parallel

Every other piece of software we build follows the opposite logic. We maintain the highest possible fidelity until the very last moment.

• Databases $\rightarrow$ don't store data as a formatted dashboard.
• Compilers $\rightarrow$ don't make Intermediate Representation (IR) "pleasant" to read.
• APIs $\rightarrow$ exchange structured schemas, not friendly summaries.

We keep the raw state and only transform it at the boundary where the human interacts with it. Currently, LLM tooling is doing this backwards.

A Better Path Forward

To be clear, I am not against accessibility or personalization. If you prefer a three-line summary, that's great—but that should be a rendering choice, not an operational one.

The Ideal Architecture:

• Agents communicate via precise, machine-facing state.
• Sub-agents exchange diffs, schemas, and exact error codes.
• The "Human Layer" acts as a final renderer.
• Personalization (e.g., "ADHD-friendly") is applied only at the output boundary.

In short: the "viral skills" we see today are actually patches for a problem that should be solved deeper in the stack. The future belongs to agents whose native tongue is precision, and whose "warmth" is merely a skin applied at the end.