auto-draftify: The AI Writing Pipeline That Separates Drafting From Judgment

A Bun-based open-source CLI that sends essays through a writer, a critic, and a revision pass, then saves every run as markdown.

8 min read · T3-Content/auto-draftify

A manuscript moves through three distinct stations on a clean editorial line. At the first station, pages are typed into a draft. At the second, a reviewer marks the pages under a lamp. At the third, the revised stack is tied neatly into a finished bundle. The scene explains the repo’s main idea: writing is treated as a sequence of roles, not a single prompt. — Drafting, critique, and revision are separated into distinct passes, which turns AI writing into an editorial workflow instead of a chat session.

Key Takeaways

auto-draftify treats AI writing as an editorial pipeline, which is a stronger pattern than asking one model to do everything at once.
Its real architectural move is role separation, with one model drafting, a different model critiquing, and the original writer returning to revise.
Bun keeps the tool lean enough to feel like a CLI utility instead of a platform, which matches the project's narrow scope.
The saved markdown artifacts matter because they make each run inspectable, comparable, and worth studying after the fact.

The real product is the loop, not the prompt

Most AI writing tools still treat the model as a single smart box. You ask for an essay, you get an essay, and any self-correction happens inside the same black box. auto-draftify makes a sharper bet: writing gets better when drafting and judgment are separate jobs.

This flow makes the core idea legible in one glance: a draft is generated, critiqued, revised, and saved as artifacts.

Claude writes. Kimi judges. Claude revises.

The repo’s central trick is not that it uses AI. It is that it uses different models for different cognitive roles. The writing pass uses Claude, the review pass switches to Kimi K2 Thinking, and the revision pass returns to Claude with feedback in hand.

export async function runEssayPipeline(topic: string) {
  const draft = await generateEssay(topic)
  const feedback = await reviewEssay(draft)
  const revised = await reviseEssay(topic, draft, feedback)

  await saveRun({ topic, draft, feedback, revised })
  return revised
}

The CLI will prompt you for an essay topic, then: 1. Generate an initial essay using model A 2. Review the essay using model B 3. Generate a revised essay using model A with the feedback

T3-Content (via t3dotgg), Project Maintainer · auto-draftify README

That choice does more than look tidy. It creates a clean division between generative fluency and critical reasoning, which is exactly what most one-model workflows blur together. The result is closer to an editor assigning a draft, an editor reading it, and the writer returning with notes, not a chatbot talking to itself.

Bun is the quiet enabler

The stack is deliberately small. Bun handles the runtime, TypeScript runs in strict mode, and the repo avoids the usual wrapper clutter that grows around small AI tools. That keeps the project feeling like a utility with a point of view, not a framework waiting for a team.

This project was created using `bun init` in bun v1.3.2. Bun is a fast all-in-one JavaScript runtime.

T3-Content (via t3dotgg), Project Maintainer · auto-draftify README

A close view of a terminal beside a filing shelf with timestamped run folders. Three markdown documents slide into a labeled folder stack while the terminal output above them stays minimal. The image explains that the repo values reproducible artifacts as much as the generated essay itself. — Every run is written to disk as markdown, which makes the pipeline inspectable instead of disposable.

The repo behaves like a production notebook

The output is not a single blob of text. It is a set of saved runs, each with its own timestamped folder and markdown artifacts. That matters because it turns a one-off generation into something you can compare, audit, and improve later.

A timestamped run folder prevents collisions and keeps sessions separated.
A draft markdown file preserves the first pass instead of overwriting it.
A review file records the critique stage, which is usually the most interesting part of the workflow.
A revised markdown file captures the final output while preserving the path that produced it.

The repository structure reinforces that discipline. `index.ts` orchestrates the pipeline, `aiClient.ts` isolates the model calls, `fileUtils.ts` handles persistence, and the `.cursor` rules reveal an AI-native development style that is explicit about process.

What it replaces, and what it does not

This is not trying to beat a full writing suite. It is trying to replace the instinct to ask one chat model to do every step of the job. That narrower goal is the point, because it makes the workflow transparent.

Workflow style	Model strategy	Output persistence	Interface	Main trade-off
auto-draftify	One model drafts, another critiques, the writer revises again	Every run is saved as markdown artifacts	Bun CLI	Less broad than a full editor, but far more explicit about process
ChatGPT or Claude	One conversational loop handles drafting and self-editing	Usually ephemeral unless the user saves it	Chat interface	Flexible, but the judgment step is hidden inside the same conversation
Editor-first AI repos	AI help inside a markdown editor	Often saved in-place inside the document	Editor with live preview	Good for writing, but the pipeline is still secondary to the interface
Closed writing suites	Model features wrapped in a product workflow	Stored inside the vendor product	Web app or SaaS	Convenient, but less inspectable and less portable

The result is an opinionated tool with a narrow thesis. It is not the most feature-rich option in the category. It is the clearest demonstration of a simple idea: if writing is a process, the software should expose the process.

Who built it

The repo comes from t3dotgg, and it reads like a reference implementation more than a product launch. That fits the project’s tone. The value here is not polish for its own sake, but a compact example of how to structure AI-assisted writing when you care about roles, artifacts, and repeatability.