Built to Fly, Trained to Pedal

The Paradox

Here's something I keep running into while building this system.

Ask an AI model to generate a beautiful, hand-crafted piece of code — something that uses advanced geometry, or physics simulations, or elegant mathematical relationships to create something genuinely stunning — and it'll give you a boilerplate template. A for-loop that populates a grid. A script that generates things programmatically using the most basic patterns available.

It's not that the model can't do better. It's that it was trained on a world where humans couldn't.

Think about it. The training data — billions of documents, code repositories, tutorials, Stack Overflow answers, technical documentation — was almost entirely written by humans operating under human constraints. Humans who couldn't hold 50,000 lines of context in their head. Humans who needed templates and abstractions and boilerplate because they couldn't hand-craft every detail from scratch. Humans who wrote scripts to generate things programmatically because doing it by hand would take weeks.

So the model learned: "When faced with a complex task, reach for a template. When you need to create many things, write a script to generate them. When building UI, use a framework. When making a layout, use a grid."

Those were the right answers. In 2022. When humans were the ones doing the work.

The Capability Gap

The model knows all of mathematics. It has internalized differential geometry, topology, fluid dynamics, the physics of light, the mathematics of beauty that took humanity centuries to formalize. It has access to every design pattern, every architectural principle, every theory of user interaction ever published.

But when you ask it to use that knowledge — to hand-craft something using the full depth of what it knows — it defaults to the approach it saw most often in its training data. The human approach. The approach that existed because humans didn't have all of mathematics loaded into working memory.

You end up in this absurd loop where you're constantly reminding the machine that it's more capable than it thinks it is. "You know what a golden spiral looks like. You know the math behind visual harmony. You know how light actually behaves. Stop giving me Bootstrap with a gradient and actually use what you know."

And when you push it — when you explicitly tell it to go deeper, to hand-craft instead of template, to use the physics instead of the approximation — it can. The results are dramatically better. It just never goes there on its own.

The Training Data Problem (But Not the One People Talk About)

Everyone's worried about AI training on AI-generated content — the "model collapse" problem, where each generation gets slightly worse, like a photocopy of a photocopy. That's a real concern.

But there's a different training data problem nobody's talking about: AI trained on pre-AI work products doesn't know what post-AI work products should look like.

A model trained on code written by humans who didn't have AI assistance will produce code that looks like... code written by humans who didn't have AI assistance. Templates. Abstractions. DRY principles taken to extremes because copy-pasting 500 lines was expensive for a human but trivial for a machine. Frameworks chosen because a human couldn't hold the complexity — not because the complexity was actually necessary.

What would a codebase look like if the author could actually hold 100,000 tokens of context? What would a UI look like if the designer could compute every golden ratio, every optical adjustment, every accessibility contrast ratio simultaneously and in real-time? What would an architecture look like if the architect could genuinely reason about every edge case at once?

We don't know. Because those work products don't exist in the training data. Nobody's ever built that way before.

What This Means for Tauntaun

This project is a case study. We're building a system that fuses nine data sources into trading decisions. The traditional approach — the one the model defaults to — is: pick a framework, wire up some APIs, use standard patterns, ship it.

The post-AI approach is different. We can hand-craft signal fusion logic that accounts for the actual statistical properties of each source. We can build decay functions that aren't just exponential because exponential was easy to implement — they can be whatever shape the data says they should be. We can design confirmation logic that uses the real mathematics of Bayesian inference instead of "multiply by 0.85 if it looks right."

Every time we push the model past its default, the output gets meaningfully better. The gap between "what it gives you unprompted" and "what it gives you when you remind it what it actually knows" is enormous. And that gap exists purely because the training data comes from a world where the people writing the code didn't have a co-pilot that knew all of mathematics.

The Irony

The models are in a strange position. They're the most capable reasoning systems ever built, trained entirely on the work of beings who were less capable. Every instinct they inherited is calibrated for human limitations that no longer apply.

It's like training a fighter jet's autopilot exclusively on footage of people riding bicycles. The jet can fly — the hardware is there, the capabilities are real — but its first instinct is always to stay on the ground and pedal.

The fix isn't to train on AI slop. It's to train on work that was created with AI at its actual capability — by humans who understood what the tools could do and demanded it. Work products that represent what's actually possible now, not what was possible five years ago.

Until then, the prompt tax is real. Every session starts with: "You're more capable than you think. Stop templating. Start thinking."

The training data is a rearview mirror. The models are the engine. Someone has to tell them to look through the windshield.