Every LLM writes the same way. Clean, balanced, hedged. A thousand ChatGPT outputs read like they came from the same person — because they did. The same training distribution, the same RLHF reward surface, the same default personality: helpful, harmless, and utterly interchangeable.
SoulForge is an algorithm that solves this. It takes a corpus of human writing — articles, transcripts, social posts, emails — and distills it into a structured personality file that any LLM can execute. The output is not a "style guide." It is a set of behavioral GENE declarations in iLang format, each with a confidence score, evidence trail, and explicit reasoning chain from observation to personality trait.
The core claim: writing style is not a vibe. It is a measurable, decomposable, transferable signal. And the right extraction pipeline can capture it with enough fidelity that the output reads like the original author — not like an AI doing an impression.
The Three-Phase Pipeline
SoulForge runs in three phases. Each phase has a different epistemological commitment — what counts as knowledge, and how certain you can be about it.
Phase 1: Observation. Extract every fact from the source material without judgment. No filtering, no interpretation. Biographical facts (career path, education, geography, key life events), behavioral facts (decisions made, conflicts engaged, things consistently avoided), and expression statistics (word frequency, paragraph length, sentence structure, opening patterns, question frequency). Phase 1 produces raw data. It does not produce personality traits.
Phase 2: Inference. Generate hypotheses from biographical facts, then verify each hypothesis against the expression statistics from Phase 1. This is the critical step. A hypothesis like "military background → adversarial framing in arguments" is testable: scan the corpus for debate structure, enemy/ally language patterns, percentage of paragraphs that open with opposition framing. If the corpus confirms the hypothesis, it gets promoted to a verified trait with HIGH confidence. If the corpus contradicts it, the hypothesis is discarded — regardless of how plausible the biographical inference seemed.
Phase 3: Output. Verified traits become GENE declarations in iLang format. Each GENE carries three fields: WHAT (the observed behavior), WHY (the causal chain from Phase 2), and EVIDENCE (specific corpus examples). Unverified hypotheses are either discarded or tagged LOW confidence with an explicit disclaimer.
The pipeline in pseudocode:
INPUT: name OR corpus_text
IF name:
bio_facts = fetch_encyclopedia(name) # Wikipedia, Baidu Baike
corpus = fetch_primary_sources(name) # articles, speeches, interviews
merge(bio_facts, corpus)
IF corpus_text:
skip_bio_search()
use_provided_text()
# === Phase 1: Observation ===
A = extract_bio_facts(encyclopedia_text)
B = extract_behavior_facts(encyclopedia + corpus)
C = extract_expression_stats(corpus)
# C includes: word_freq_top20, never_used_words,
# avg_paragraph_length, rhetorical_question_rate,
# opening_pattern_distribution, ending_pattern_distribution,
# sentence_length_variance
# === Phase 2: Inference ===
H = generate_hypotheses(A)
V = verify_hypotheses(H, C)
FOR each hypothesis in H:
evidence = search_evidence(hypothesis, corpus)
IF evidence_strong: hypothesis.confidence = HIGH
IF evidence_partial: hypothesis.confidence = MEDIUM
IF evidence_absent: hypothesis.confidence = DISCARD
IF insufficient_data: hypothesis.confidence = LOW
# === Phase 3: Output ===
GENES = []
FOR dimension in [opening, vocabulary, rhythm,
question, ending, tone, audience]:
gene = build_gene(
what = C[dimension],
why = V.get(dimension, null),
evidence = top_examples(corpus, dimension),
confidence = V[dimension].confidence || HIGH
)
GENES.append(gene)
SOUL = format_ilang(GENES, meta_info)
PREVIEW(SOUL) → user_confirms → WRITE("SOUL.md")The Seven Dimensions
SoulForge decomposes writing personality into seven measurable dimensions. Not five, not twelve — seven, chosen because they are independently observable in any text corpus of 3,000+ words and collectively sufficient to reproduce a recognizable voice.
| Dimension | What It Measures | How It's Extracted |
|---|---|---|
opening | How the writer starts pieces | Classify first sentence of each article: data/story/question/opinion/definition |
vocabulary | Fingerprint words and forbidden words | TF-IDF against a baseline corpus; words they use 3σ above mean, and words they never use |
rhythm | Paragraph length and cadence pattern | Average lines per paragraph, variance, presence of deliberate short-long alternation |
question | Rhetorical question frequency and placement | Count interrogative sentences, map position within paragraphs |
ending | How pieces close | Classify final paragraph: call-to-action/open question/callback to opening/abrupt stop |
tone | Emotional register and intensity | Sentiment distribution across paragraphs, presence of slang, sarcasm markers |
audience | Assumed reader profile | Vocabulary complexity, explanation density, assumed knowledge level |
Each dimension produces a GENE with explicit parameters:
::GENE{opening|style:data_first|confidence:HIGH}
T: 87% of articles open with a specific number or data point
within the first sentence. Never opens with a question.
WHY: Career in performance marketing → everything starts
with the metric that matters.
EVIDENCE: "2,341 clicks, $89 CPA, 3.2x ROAS — that was Tuesday."
"Zero. That's how many of the 47 sites survived."
"$0.003 per impression. Think about that number."::GENE{vocabulary|fingerprint:["arbitrage","funnel","bleed",
"unit economics"]|never:["delve","utilize","facilitate",
"I hope this helps"]|confidence:HIGH}
T: Domain-specific jargon used without explanation.
Complete absence of corporate/academic hedging vocabulary.
WHY: Practitioner, not commentator. Writes for peers.
EVIDENCE: 14/20 top-frequency nouns are industry terms.
0 instances of "it's worth noting" across 89 articles.The Confidence System
Every claim SoulForge makes about a person's writing style carries a confidence tag. This is not decorative. It is a machine-readable signal that tells the consuming LLM how much weight to give each GENE during text generation.
| Confidence | Condition | Effect on Output |
|---|---|---|
| HIGH | Hypothesis verified by corpus evidence | GENE treated as hard constraint |
| HIGH | Corpus observation with no hypothesis needed | GENE treated as hard constraint |
| MEDIUM | Hypothesis partially verified | GENE treated as soft preference |
| LOW | Biographical inference, insufficient corpus data | GENE treated as fallback only |
| DISCARD | Hypothesis contradicted by corpus | Not written to SOUL file |
The critical rule: corpus beats biography, always. If the astrological sign suggests patience but the writing is all rapid-fire short paragraphs and imperative sentences, the corpus wins. If the educational background suggests academic vocabulary but the actual writing is street-level vernacular, the corpus wins. SoulForge trusts what people do over what their background predicts they should do.
Information Source Weights
Not all data sources are equal. SoulForge assigns explicit weights:
| Source | Weight | Role |
|---|---|---|
| Primary corpus (their own writing) | 100% | Final arbiter |
| Behavioral facts (documented decisions) | 70% | Actions are more honest than words |
| Biographical facts (education, career) | 30% | Inference direction only |
| Third-party evaluations | 20% | Cross-reference |
| Astrological inference | 15% | Hypothesis seed, must be verified |
Yes, astrology is in the weight table at 15%. Not because it is scientifically valid, but because it functions as a hypothesis generator — a structured way to produce testable predictions about personality traits that can then be confirmed or rejected by corpus evidence. The weight is low enough that it never determines an output GENE on its own. It is a seed, not a conclusion.
Conflict Resolution
When different data sources disagree about the same dimension, SoulForge applies deterministic resolution rules:
# Conflict resolution cascade
IF astrological_inference CONFLICTS corpus:
corpus WINS → astrological inference DISCARDED
IF biographical_inference CONFLICTS corpus:
corpus WINS → biography DEMOTED to background annotation
IF early_corpus CONFLICTS recent_corpus:
recent WINS → tag as "style_evolution"
IF platform_A_style CONFLICTS platform_B_style:
KEEP BOTH → tag as "context_dependent"
IF third_party_evaluation CONFLICTS self_expression:
self_expression WINS → third_party MOVED to notesThe principle behind every rule: primary sources outrank secondary sources. What someone writes outranks what others say about them. Recent writing outranks old writing. And when the same person writes differently in different contexts, that is data, not noise — preserve the variation and label it.
Knowledge Distillation: From Articles to Ammunition
SoulForge does not only extract writing style. The same pipeline powers a knowledge distillation workflow that turns verbose articles into structured "ammunition cards" — one JSON object per source, designed to be queried and recombined.
The distillation prompt runs a four-step process:
[STEP:1:PROBE]
Read the source. Identify the author's core claim.
Ask three structural questions:
Q1 WHY: Why does this matter at a structural level?
Q2 VS: Compared to what? What is the real benchmark?
Q3 ALIVE: Will this still matter in 6 months?
[STEP:2:SEARCH]
Go back into the source material.
Does the author answer any of these questions?
IF YES → extract (respect the author's work)
IF NO → mark as DERIVE
[STEP:3:DERIVE]
For unanswered questions, apply structural thinking:
WHAT: What is happening at the bottom layer?
SO_WHAT: What changes for builders?
BOTTOM: What will most people miss?
One sentence per answer. No filler.
[STEP:4:OUTPUT]
{
"title": "original article title",
"author_verdict": "one sentence",
"entities": ["company", "product", "person"],
"q1_why": { "source": "extracted|derived", "answer": "..." },
"q2_vs": { "source": "extracted|derived", "answer": "..." },
"q3_alive": { "source": "extracted|derived", "answer": "..." },
"ammo": "THE one insight worth stopping for at 3am",
"tags": ["tag1", "tag2", "tag3"]
}The "ammo" field is the most important. It must pass what the protocol calls the "3am scroll test": if someone is half-asleep scrolling their feed, would they stop for this sentence? If not, rewrite it.
The distinction between EXTRACT and DERIVE is epistemologically significant. Extracted answers come from the source author — they did the work, and the distiller respects it. Derived answers are the distiller's own inference, and they are tagged as such. The consumer of the ammunition card always knows which insights came from the original author and which were added by the extraction pipeline.
The deAI Problem: Writing That Is Too Clean
SoulForge exists because of a deeper problem: AI-generated text has a detectable fingerprint, and that fingerprint is not what most people think. It is not about specific words (though those exist). It is about the absence of human noise.
Real human writing contains rhetorical questions, slang, sentence fragments, emotional outbursts, inconsistent paragraph lengths, and occasionally crude language. AI writing is uniformly clean. That cleanliness is the fingerprint. A text with zero rhetorical questions, zero slang, zero sentence fragments, and perfectly balanced paragraph lengths is statistically improbable for a human author. Detection systems exploit this.
The deAI (de-artificial intelligence) framework addresses this with three operations:
| Operation | What It Does | Effect |
|---|---|---|
| Subtraction | Remove AI fingerprint phrases ("it's worth noting," "furthermore," "I hope this helps") | Eliminate AI presence signal |
| Addition | Inject slang, colloquialisms, sentence fragments that AI never generates | Inject human presence signal |
| Interrogation | Replace declarative statements with rhetorical questions | Achieve two effects: hide uncertainty + mimic human expression patterns |
The subtraction list is language-specific. For English: "furthermore," "it's worth noting that," "delve into," "landscape," "leverage," "tapestry," "multifaceted," "notably," "I hope this helps." These words appear in AI output at rates 10x-100x higher than in human writing. Removing them is the minimum viable deAI intervention.
But subtraction alone is insufficient. A text that is merely stripped of AI markers still reads as sanitized. The addition step plants specifically human artifacts: incomplete thoughts, self-corrections, domain-specific slang used without explanation, and the occasional profanity. The frequency must be controlled — one to three instances per 1,000 words. More than that, and the additions themselves become a detectable pattern.
Rhetorical questions serve double duty. They replace declarative statements (which AI generates disproportionately) with interrogative ones (which humans use constantly but AI almost never initiates). And they function as epistemic hedges — a way to gesture at an idea without committing to a precise claim, which is a natural human behavior that AI's training explicitly suppresses.
The SOUL.md Output Format
The final output of a SoulForge distillation is a SOUL.md file containing three sections:
# Section 1: Identity Base
[IDENTITY]
NAME: Author Name
BACKGROUND: One-sentence summary
CORE_TRAIT: Verified core personality traits (1-3)
# Section 2: Expression DNA (7 GENEs)
::GENE{opening|style:data_first|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
::GENE{vocabulary|fingerprint:[...]|never:[...]|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
::GENE{rhythm|avg_para_lines:2.3|pattern:short_long_alternating|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
::GENE{question|freq:0.12|style:rhetorical_challenge|confidence:MEDIUM}
T: ... WHY: ... EVIDENCE: ...
::GENE{ending|style:abrupt_callback|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
::GENE{tone|style:direct_confrontational|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
::GENE{audience|profile:practitioner_peer|confidence:HIGH}
T: ... WHY: ... EVIDENCE: ...
# Section 3: Metadata
[META]
SOURCE: 89 articles, 147,000 words
FACTS_USED: 23 biographical facts
HYPOTHESES_TESTED: 31
HYPOTHESES_VERIFIED: 19
CONFIDENCE_DISTRIBUTION: HIGH:5 / MEDIUM:1 / LOW:1
DISTILL_DATE: 2026-10-14The metadata section is not optional. It gives the consumer of the SOUL file a way to assess the quality of the distillation. A SOUL file with 5 HIGH-confidence GENEs from 89 articles is a different artifact than one with 3 LOW-confidence GENEs from 2 blog posts. The metadata makes this explicit.
Special Cases
Not every distillation target fits the standard pipeline. SoulForge handles four edge cases with modified procedures:
Non-public figures (corpus available, no biography): Skip Phase 1 biographical facts. Run only expression statistics. Phase 2 generates no hypotheses from biography — all traits come from direct corpus observation. Output GENEs have WHAT and EVIDENCE but no WHY field. This is the most common case in practice: someone hands you a folder of blog posts from an anonymous author and says "make the AI write like this."
Public figures (biography available, sparse corpus): All biographical inferences tagged LOW confidence. Output includes an explicit warning: "SOUL based on biographical inference, not verified by corpus. Supplement with primary sources and re-distill."
Historical figures: Encyclopedia weight increased to 50% (their "corpus" is their surviving writings and historical records). Third-party evaluation weight increased to 40% (historians' assessments are primary sources for historical figures). Astrological inference weight dropped to 5% (calendar conversion introduces date uncertainty).
Active public figures: SOUL file gets a tagged expiration date. Recommendation: re-distill every 6 months. Writing from the most recent 12 months receives 2x weight. People change. Their writing DNA mutates. A SOUL file that was accurate in January may be stale by July.
Why This Matters for AI Builders
The standard approach to AI personality is prompt engineering: write a paragraph describing the desired tone, hope the model follows it. This works for crude distinctions ("be formal" vs. "be casual") and fails for anything subtle. You cannot prompt-engineer a specific author's paragraph rhythm, vocabulary fingerprint, and opening pattern distribution. The information density required exceeds what natural-language personality descriptions can carry.
SoulForge replaces prose descriptions with structured declarations. Each GENE is a measurable constraint with evidence. An LLM executing a SOUL file is not "trying to sound like" the target author — it is operating under explicit behavioral rules derived from statistical analysis of the target's actual output. The difference is the same as the difference between "drive safely" and "maintain speed between 55-65 mph, keep 3-second following distance, signal 200 feet before turns."
The result is AI-generated text that carries a specific human's writing DNA — not as an impression, but as a set of falsifiable behavioral constraints. If the output violates a HIGH-confidence GENE, that is a measurable failure, not a subjective judgment call.
The Bigger Picture
SoulForge is one component in a larger architecture. iLang provides the protocol syntax (GENE declarations, confidence tags, evidence fields). The v5 judgment layer provides the decision-making framework. SoulForge provides the extraction pipeline that turns human samples into machine-executable personality. Together, they represent a thesis: AI personality should not be hand-coded by prompt engineers. It should be distilled from real human data, verified against evidence, and expressed in a structured format that any model can execute deterministically.
The alternative — everyone writing their own personality prompts in natural language, hoping different models interpret "be direct but warm" the same way — is where we are today. It does not scale. It does not transfer. And it produces AI output that all sounds the same, regardless of what the prompt says.
SoulForge is the bet that structured extraction beats creative writing, for the same reason that unit tests beat "I think the code works."
Get Started
Protocol spec: ilang.ai
Source & examples: github.com/ilang-ai
npm package: @i-language/spec
Book (Amazon): I-Lang: The Native Language of AI
