Obliqui

Obliqui is a writing environment for people who like to write. Not a robot that writes the book for you: a genuinely good place to do the work, with AI you can turn all the way up, all the way off, or anywhere in between. The line I keep coming back to has been the editor is the meal; AI is the seasoning.

This is the honest, mid-build version of what I’m making, how it got here, and where it’s going. Not a launch post (yet).

What it is

Obliqui has three postures, switchable like the mode dial on a camera:

• No-AI. Notes, outline, annotations, focus mode, sessions, snapshots. Genuinely AI-free: no suggestions, no nags, no “are you sure?”
• Assist. A thinking partner you summon, rephrase, voice-drift checks, overuse and synonyms, research, brainstorm. Never ambient, always opt-in.
• Pipeline. The unique engine: generate a draft through staged AI passes you can steer.

The one that matters most is No-AI. Most “AI writing tools” can’t actually turn the AI off, there’s always a ghost suggestion, a panel, a button waiting to finish your sentence. In No-AI mode Obliqui removes every AI surface: the analysis panel, rephrase-on-selection, the regenerate actions, the status glyphs. Gone. It’s a trust signal as much as a feature: this is a real writing tool first, and the machine is opt-in, not assumed.

How I got here

Obliqui started life as a Python CLI: a proven, eight-stage ghostwriting pipeline. It worked, and it still does, and it’s the basis of the primary engine to this day. From there I rebuilt the surface as a web product, Go on the back and React on the front, aiming at a real V1.

This was never greenfield. Along the way I’d already built the manuscript editor, a voice library with per-writer profiles, writing analytics, plan and upgrade flows, a full SVG icon pass, a keyboard-shortcut system, row-level-security hardening across the schema as go-live crept closer, and a consolidation of three separate repos (CLI, backend, UI) into one monorepo with history intact.

And then the obvious thing finally landed. For a while I was building an AI pipeline that happened to have an editor bolted on. But I love to write, and so do the people I’m building this for.

As I realized, sometimes in the pursuit of a technical accomplishment, you can lose sight of the actual purpose of what you are building. When I started to use the new project for my own writing workflows, it was clear I was going to have to change directions a bit.

Sure, the pipeline is wicked fun to build and tune. But it’s also a narrow, crowded niche that robs the writer of the joy of writing by default. So I flipped it, back to what it should have been all along: make the editor best-in-class, and make the pipeline one option among many.

Not a pivot necessarily so much as an amplification, the editor should have always been the core value; I’d just been letting the pipeline define the product too much. Repositioning, it turns out, is quite often just the subtraction of your own ego about the cool parts, your pet ideas in a project.

Nobody owns the middle

The market is split cleanly in two. Craft tools (Scrivener, Ulysses, iA Writer) own “no AI,” but they can feel dated and locked-in. AI tools (Sudowrite, NovelCrafter, NovelAI) own “generate,” but they treat the editor as an afterthought.

Nobody owns the middle: a genuinely great editor, with tasteful optional AI, and a full pipeline for when you actually want one. That gap is the whole bet. The design principle I borrowed from the calmest AI products is that the AI should recede, it lifts, it doesn’t replace. Gray AI text sitting next to black human text. Provenance you can see.

How it’s built

The backend is Go: a Chi API plus an Asynq worker on Redis, where the pipeline stages run as background jobs that pause at gates for human review. Data is Supabase Postgres through pgx, and the canonical fields, the raw input and the original text, are protected by database triggers so the source is never destroyed.

The frontend is React 19 on Vite with Tailwind v4, a token-based theme system, and a real manuscript editor: a paragraph model, character-range annotations, focus mode, sessions, analysis, export. Auth is Supabase JWTs validated in Go; billing is Stripe.

One deliberate abstraction sits in front of the models. Users never pick a vendor or a version number, they pick a Quill, a branded persona with a character instead of a spec sheet: Wisp for fast drafts, Specter for the daily driver, Phantom for the richest prose.

Under the hood the pipeline can route mechanical steps to a fast Quill and creative steps to a richer one, invisibly.

And there are no token counts, no credit meters, no dollar figures anywhere a writer can see them. Credit anxiety is the fastest way to make someone ration their own creativity. Write all you want; I did the cost math so you don’t have to.

Changing it without breaking it

Here’s the part I’m proudest of, and it isn’t a feature. The app was already mature, which is exactly the trap: when you redesign the experience inside your own codebase, every idea gets quietly bent toward what’s cheap to change, not what’s right. The data model, the routing, the components you already have, they all pull on you.

So I added a step to my own process: a throwaway, fully-styled prototype, the same component library and brand tokens as production, but mock data only and no backend. A design sandbox. Its job was not to figure out how to ship new features, but what to ship, and just as importantly, how it should feel to the end user.

Being able to work free from constraint, the editor-first shell, the posture dial, the provenance language, at speed, with nothing real to break, rapid progress followed.

And before folding anything in, I wrote the design system down as a contract: the token taxonomy, the typography roles, the golden rules (never hardcode a color, no light/dark branching in components).

“Be careful” doesn’t survive a busy week or a context switch. A written contract turns taste into a checklist, so “make it better” can’t quietly come to mean “make it inconsistent.”

Where it actually is

Honest status, because this is a build log. The base is mature: the editor is real and deep, sitting on top of everything above. This last stretch is only in my mind and machine, it is not yet deployed.

In it I added a persisted Scene layer (sub-chapter grouping, done additively so existing manuscripts can’t break), the posture dial with a real No-AI mode that hides every AI affordance, some chrome consolidation, and enough local-dev hardening that a fresh clone actually boots and hands you a usable account for rapid iteration.

None of that is in anyone’s hands yet. Hopefully soon. The list below is genuinely next, not quietly already done.

What’s next

• Finish the shell: the editor as the default surface, the pipeline reframed as a posture rather than a separate destination.
• Provenance everywhere: the gray-AI / black-human layering, plus an exportable authorship report (“X% human, Y% AI-assisted”) as a trust artifact.
• The assist layer: conversational rephrase, voice-drift, overuse and synonyms, all posture-gated, all calm.
• Net-new surfaces: a Codex (a story wiki), a Concept workspace for pre-draft thinking, a Lorebook for keyword-triggered context.
• AI based detection: automatically analyze manuscripts pasted or as they are written, to populate the new surfaces - character detection, scene detection, presence charting, and more
• Voice tuning: the real moat is making the AI sound like you, not like a chatbot.
• A launch that leads with the editor, not a robot.

What it’s teaching me

A few things this stretch has hammered home.

• Repositioning is mostly subtraction of your own ego.
• Prototyping without constraints helps you find what you should make, not what’s easy to make.
• “Don’t rewrite working systems” is easy to say and genuinely hard to honor when the new thing is shinier.
• The boring work, the migrations, the local-dev plumbing, the provenance wiring, is what makes the fun work possible at all.

If a launch that leads with the editor instead of the AI sounds backwards for an AI writing tool, good. I think that’s the whole idea here.