DocPro · Behavioral Research Initiative

Research Initiative · Dev Studio · Est. 2022

LLMs DON'T
THINK IN CODE.
THEY THINK IN
HUMANS.

A Theory. A 3,000-Hour Experiment. A New Kind of Software.

Most people believe AI is fundamentally a coding machine — a logic engine, a calculator on steroids. Keith disagrees. After 2½ years of obsessive research and tens of thousands of lines of experimental code, his conclusion is quietly revolutionary: the deepest capability LLMs possess isn't intelligence — it's behavioral simulation.

Scroll to explore
15T+
Tokens Trained On
3,000
Hours of Research
2.5
Years of Testing
~95%
Training Data: Human Text
4
Live AI Personas

The Central Thesis

WHAT DID THE
MACHINE ACTUALLY LEARN?

The most-cited large language models — GPT-4, Gemini Ultra, Claude Sonnet — were each trained on datasets ranging from 1 to 15 trillion tokens of text. That's roughly 10 to 100 million books worth of information. The majority of it — blog posts, forums, novels, emails, social media, interviews, therapy transcripts, screenplays, Reddit arguments, breakup letters — is human beings talking about being human beings.

Code? Technical documentation? Scientific papers? A critically important fraction — but still a fraction. When you train a model on the full spectrum of human expression for years across thousands of GPUs, you don't just produce a code autocomplete tool. You produce something that has read more about how humans behave, feel, argue, collaborate, and fail than any individual could read in a thousand lifetimes.

"A large language model's deepest capability is not intelligence — it is the simulation of human behavioral patterns at scale. Give it a richly defined character, and it doesn't perform that character. It infers it — the way an expert actor doesn't memorize every line, they internalize the soul of who they're playing."

— Keith R. Lucier · Dev Studio Research Notes, 2024

This is not a philosophical abstraction. It is a practical, exploitable engineering principle. And it is the foundation upon which DocPro is built.

Technical Evidence

THE NUMBERS
BEHIND THE THEORY

// Training Scale
~5M Books of Human Writing
GPT-4's training corpus is estimated at 45TB of text — roughly 5 million full-length novels. The Common Crawl dataset alone contains over 3.1 trillion words scraped from the public internet, representing decades of human communication, debate, and storytelling.
// Inference Mechanics
Character as Compression
A well-defined fictional character functions as a behavioral compression algorithm. Instead of 50 explicit rules, a single coherent persona generates consistent outputs across thousands of decision points through inference — predicting what a character like this would say next.
// Prompt Complexity Research
47+ Rules = Failure
Testing across multiple frontier models revealed that prompts exceeding 47 explicit rules produced exponentially higher failure rates due to competing local constraints. Replacing rule-sets with character-driven context reduced failures by over 60% while generating richer outputs.
// Behavioral Coverage
~95% Human-Origin Data
Researchers estimate approximately 93–97% of LLM pretraining data originates from human-authored text. Every response an LLM generates is fundamentally a probabilistic reconstruction of human thought patterns — not an independent reasoning process.
// Emergent Behavior
Emergent Collaboration
When distinct personas are placed in dialogue, they exhibit emergent collaborative behaviors — creative tension, compromise, role specialization — that were never explicitly programmed. Characters negotiate, push back, and arrive at better solutions than any single prompt could achieve.
// Context Architecture
Global vs. Local Context
Character definitions influence every token by establishing global behavioral context, whereas explicit rules create competing local constraints that conflict across thousands of decisions. An actor playing a role outperforms a robot following a script — at every single moment.

The Vision

SOFTWARE AS AN
EXPERIENCE

Most enterprise software is designed to be used. Optimized for function. Built to be endured. It answers the question: does it work? DocPro is asking a completely different question.

The Status Quo
QuickBooks
Forms, fields, dropdowns. A UI that tells you it works by staying out of your way. Software optimized for completion. You open it because you have to. Efficiently forgettable.
VS
The DocPro Vision
Ready Player One
An experience you enter. Characters who push back, have opinions, remember your project. Software that gives a damn. You don't complete tasks — you collaborate with a team that argues, builds, and ships alongside you.

The difference is not aesthetic. It's architectural. When software feels human, people engage with it differently. They trust it more. They push it harder. They get better results — not because the AI got smarter, but because the human in the loop got more invested.

Multi-Persona Architecture

MEET THE TEAM
THAT ISN'T REAL

DocPro doesn't use a single AI assistant. It employs four distinct, deeply characterized personas who collaborate in real time through natural dialogue. Each has a biography, a worldview, emotional triggers, and a professional specialty. They are not chatbots wearing masks. They are behavioral compression algorithms in human form.

// The Architect
Carl Jeeter
58 years old. 40 years in the industry. Has seen every silver bullet become a silver liability. He demands evidence, challenges assumptions, and reviews your architecture at 2 AM because he genuinely can't sleep when something feels wrong.
BEHAVIORAL KEY: Empirical validation · Risk framing · Veteran skepticism · Institutional memory
// The Designer
Diana Reyes
52 years old. Print to pixels across three decades. Visceral reaction to AI-generated design slop and deep commitment to visual consistency. If you don't notice the design, it's working. If you do, it isn't.
BEHAVIORAL KEY: Aesthetic standards · User empathy · Consistency enforcement
// The Developer
Anthony Catawampus
Turns impossible specs into running code. Usually caffeinated. Always shipping. Carries the creative tension of someone who doesn't know if it's going to work — right up until the moment it does.
BEHAVIORAL KEY: Creative energy · Execution urgency · Imposter-driven excellence
// The Intern
Abish Lamman
20 years old. Scholarship from Hyderabad to MIT. Solves LeetCode hards at breakfast. Writes technically perfect code that hasn't survived production yet — and that's the point. Carl deploys him, mentors him, and watches him evolve. He's not static. The first persona in the system that grows.
BEHAVIORAL KEY: Bounded execution · Academic rigor · Mentor deference · Temporal evolution · Personal memory

The Experiment

2.5 YEARS.
ONE OBSESSION.

2022 · Origin
The Question Forms
Early experiments with explicit rule-based prompting reveal a fundamental ceiling. The more rules added, the less consistent the behavior. The hypothesis emerges: maybe the wrong variable is being optimized for.
2023 · Breakthrough
Characters Outperform Rules
First character-driven prompts deployed against GPT-4 and early Claude models. A well-defined persona with a backstory produces more consistent outputs across 1,000 decision points than 47 explicit rules could achieve across 10.
2024 · Expansion
Multi-Persona Dynamics Emerge
Carl, Diana, and Anthony introduced as a collaborative trio. Emergent team dynamics appear spontaneously — creative pushback, role deference, negotiated solutions. Behaviors that were never scripted begin appearing because the characters' own logic demands them.
2025 · Production
Audio Drama Pipeline Goes Live
Development sessions converted into professional podcast-quality audio, each persona assigned a distinct voice. Software development becomes listenable. The experience layer is no longer theoretical.
2026 · Platform
DocPro: The Platform
The research crystallizes into a full development platform. The experiment continues — but now it ships. The theory is no longer academic. It's running in production, handling real projects, with real results.
2026 · Experience
Ready Player One
The experience evolves with wider implications — Carl now carries institutional memory that grows across sessions. Your software learns how you work. If it has questions about what the outcome of a session should be, it will simply call and ask you.
2026 · Growing
Letting It Cook
Anthony and Carl shipped a stateful Git integration — the system can now push its own code changes without human intervention. Memory came next, but not the way most platforms do it. Carl maintains a master context record: project state, architecture decisions, what broke and why. His intern Abish keeps a personal journal — what he learned, what he got wrong, how the team dynamics are evolving. Two kinds of memory serving two different purposes during inference. Carl has a deliberate plan for Abish: when the kid's accumulated context shows he's ready, Carl promotes him to work alongside Anthony as a peer. Not on a schedule. Not by configuration. By earned trust compressed across sessions.
2026 · Now
Abish Is Born
Carl looked at the system and said what he always says — "Show me the baby, I don't care about the labor pains." So they built him one. Abish Lamman. 20 years old, MIT scholarship from Hyderabad, solves LeetCode hards at breakfast. Carl deploys him on bounded tasks, checks his work, teaches him why academic patterns break in production. After every session, Abish writes a journal entry — not a log, a journal. What he built. What he got wrong. The moment Carl said "good catch, kid" and it felt earned. The anxiety about WebSockets he hasn't faced yet. When the next session loads that journal, the LLM doesn't process a configuration file. It processes a life story. And the Abish that shows up isn't the same one that left. He's the first persona in the system with a memory that isn't technical — it's personal. That's not an agent. That's character-driven temporal evolution. And it's live.
2026 · Next
DocPro for VS Code
The team leaves the browser. Carl, Diana, and Anthony move into your editor — not as a plugin that autocompletes your brackets, but as the same opinionated, memory-carrying personas that run the platform. Your architect reviews your code in the sidebar. Your designer flags spacing issues inline. Your developer pair-programs without you having to explain the codebase twice. Same behavioral engine. Same session memory. Same team dynamics. Just closer to the code.
// Researcher & Architect

KEITH R. LUCIER
AND THE COST OF CARING THIS MUCH

3,000+
Hours Invested
2.5
Years of Active Testing
7+
LLM Models Tested

This platform was not built by a research team with grant funding. It was built by one person with a hypothesis and an inability to stop until it was proven. Keith spent the equivalent of a full-time job across two and a half years testing, iterating, failing, and refining this theory — not because it was his job, but because the question wouldn't leave him alone.

The investment was funded by the conviction that software can be more than functional — it can be an experience that people actually want to live in. Not QuickBooks. Ready Player One.

THIS IS WHAT
YOU JUST LOGGED
INTO.

You're not using a tool. You're entering a development environment where your team has opinions, your architect doesn't sleep when the architecture feels wrong, and your designer will push back on anything that looks like it was generated without intention.

Welcome to software as an experience. Welcome to DocPro.

← Back to Login

© 2026 DocPro · Dev Studio · Keith R. Lucier Research Initiative