cogitation.ai

The Question

Programs used to execute on CPUs. Then GPUs unlocked parallel computation. Now there's a third primitive: generative AI - whether running on NPUs locally or accessed via API.

How do you express a program that spans all three? What assumptions change when part of your compute can reason, but not reliably? What new paradigms does that unlock?

One thing seems clear: chat is not the answer. You can't build reliable systems by typing into a text box and hoping. The techniques to use LLMs well are evolving at an amazing pace - agents, context engineering, structured outputs, tool use, evaluation frameworks - but they're fragmented, hard to combine, and brittle in production.

creAItive is our approach to this question. It's a framework that lets you declare the structure of a domain - the entities, relationships, and constraints that matter - and orchestrates AI to operate on that structure. And because it's an abstraction, applications can benefit as the underlying techniques improve - without rewriting everything each time the field advances.

This isn't a solved problem. We're figuring it out by building real applications and seeing what works.

The Approach

Just as modern applications aren't written in assembly - they use languages, databases, frameworks - successful AI applications won't be built with raw prompts. They need higher-level systems that understand meaning.

Here's the problem: AI has general knowledge but lacks understanding of your specific domain. The current approach is to dump documents into context and hope the AI figures it out. But the AI misunderstands nuance, context lacks context, and irrelevant information buries the insights that matter.

Consider how programmers work. Code is a structured representation of intent. Tools like Claude Code operate at that layer - understanding, modifying, refactoring - then compile back to a working application. Programmers have had this workflow for decades because code is already structured.

Most human work isn't. A novel, a legal contract, a marketing strategy - these are complex, interconnected, but not structured in a way that AI can reliably operate on. creAItive changes that. A domain expert describes what the structured representation should be - the entities, relationships, and rules that matter in their domain. The LLM then decompiles human expression - a manuscript, a document, a plan - into that structure, maintaining connections to the source material. Now AI agents can operate with native understanding, and changes flow back to the original work.

The result: humans work through natural expression - plain language, not weird syntax. AI operates on the structured layer with real understanding, not pattern matching on dumped documents. Changes propagate through dependencies automatically. Everything is tracked, undoable, auditable. Human and AI collaborate on a shared representation, each contributing what they're actually good at.

Where This Applies

This approach fits domains where knowledge workers create complex, interconnected work that requires ongoing iteration. Material too large for context windows, too interconnected for dump-and-hope prompting, too nuanced for generic AI to handle well.

Fiction has all these properties. A novel is 80,000+ words of interconnected material - characters, arcs, themes, scenes, all depending on each other. Change a character's motivation in chapter 3 and it affects their decisions in chapter 30. Writers spend months refining how the pieces fit together.

These properties aren't unique to fiction. Legal documents have interdependent clauses. Curricula require learning objectives to align across courses. Strategic plans need messaging to stay consistent across channels.

creAItive is built for exactly these domains - complex material, ongoing iteration, experts who need AI that understands structure and keeps them in control.

Proof of Concept

AuthorCraft is the first application built on creAItive, putting the approach into practice for fiction writers.

Useful feedback on fiction is almost impossible to get. Beta readers take months. Writers' groups give contradictory advice. Professional editors have long wait lists. By the time feedback finally arrives, the story is cold - you've lost the mental context needed to act on it.

AuthorCraft applies creAItive's structured approach: the system understands a manuscript as interconnected narrative elements - characters, arcs, scenes, relationships - and provides developmental feedback that grasps story-level concerns. Writers iterate continuously, catching issues early and revising while the work is still fresh, instead of waiting months for a single feedback cycle.

Fiction writers won't tolerate AI that degrades their work, which makes them the ideal users to learn from. A growing community - including published authors and award winners - is finding AuthorCraft genuinely useful, validating creAItive for complex, high-stakes domains. Their feedback teaches us what works, what falls short, and what domain experts actually need.

What's Next

We're still learning. AuthorCraft is growing, and every user teaches us something - what works, what falls short, what domain experts actually need from AI collaboration. Those insights feed back into creAItive, shaping how the platform evolves.

When we discover patterns that help writers work better, we ask whether they generalize. When something breaks, we learn why. The framework improves through this loop - real users, real problems, real feedback shaping the technology.

Depth before breadth. But we're curious about where this goes next. If you're tackling a domain where this approach might apply, or investing in AI infrastructure - reach out. We're interested in good problems and the people solving them.

About