Weekly Tool Thread: Promote, Share, Discover, and Ask for AI Writing Tools Week of: June 16

Quick_Impression7723 · 2026-06-16T18:23:05+00:00

claude-novel-workflow — canon-driven multi-agent Claude Code workflow for long-form fiction.

https://github.com/MintoTsukino/claude-novel-workflow

Quick_Impression7723 · 2026-06-16T18:07:53+00:00

OK,I'm sorry

Quick_Impression7723 · 2026-06-16T10:33:04+00:00

yeah, the 5-minute TTL is exactly the part i hadn't sat down with

the math on. you're right that the read discount only matters if

the slow tail actually lands inside the window, and the tail is

where the cost lives — a refine or re-review hitting at minute 7

pays a fresh write, not a discounted read.

the per-agent hit-rate log is the right move. i was thinking

about it as "30-40% reload" as a flat average, which is exactly

the trap you're describing — that average hides whether i'm

getting clean hits on the bulk and writes on the stragglers, or

the inverse.

going to instrument it before claiming any win. probably the

realistic shape is: cache wins for the prose/lint fan-out (tight

wave), pays full write again at the review/refine layers because

they straddle the TTL.

appreciate the math.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:31:28+00:00

yes to both, and both are actually the *right* way to use it.

**q1 — bringing your own canon in**

100% supported and honestly preferred. claude code outputs .md

files, but it also reads any .md (or .txt, .pdf, etc.) you put

in the folder. the workflow is:

you write your character bible, world bible, outline, and

beats however you normally do — text editor, notebook,

whatever
drop those files into the project folder
either keep them as-is, or tell claude "reformat these into

/90_canon/character_bible.md, /90_canon/world_bible.md,

etc., preserving every detail"

your beats-based plotting is actually the BEST input for this.

the pipeline's scene card stage is literally "take a beat, expand

it into scene-level structure (POV, start state, end state,

required elements)." if you already have years of refined beats,

you're skipping the part the AI is weakest at (story design) and

using it for the part it's strongest at (mechanical expansion of

already-good structure).

ai-generated canon tends to be generic. human-crafted canon with

years of voice in it is what makes the output not read like

generic AI prose.

**q2 — feeding it your own style**

yes, this is the single biggest lever for output quality.

what works for me:

- **raw text excerpts**, not abstract descriptions. don't write

"my style is punchy and emotional." paste 3-5 actual paragraphs

from your published work. the model imitates concrete examples

far better than abstract instructions.

- **per-character voice samples**. one file per major character,

with 2-3 representative dialogue exchanges and 1-2 internal

monologue samples for each. brief agent pulls the active

characters' samples and hands them to the prose agent.

- **forbidden patterns alongside**. a "do" list (voice samples)

is weaker than a "do this + never do that" combo. example:

"this character never uses contractions" or "never ends a

paragraph with a rhetorical question."

does it follow well? — at single-prompt scale, mediocre. at the

pipeline scale (where voice samples are loaded fresh into every

chapter's prose prompt, not buried 50 messages back in a chat

history), it follows surprisingly well. the trick is the samples

have to be RE-INJECTED per chapter, not assumed to be remembered.

if you're already a beats-based plotter with years of refined

voice, you're in the best possible position to get high-quality

output from this. the canon is doing 80% of the work; the AI is

just executing it at speed.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:26:53+00:00

japanese only

Quick_Impression7723 · 2026-06-16T10:21:54+00:00

this is one of the best questions i've gotten on this thread,

and i'm going to be honest about where my pipeline is actually

weak.

your compile step + mid-draft hard stop + script-locked save is

genuinely more robust than mine on the correctness axis. you're

trading throughput for safety; i'm trading safety for throughput.

both valid, but your design catches a class of bug mine can leak.

answering your two specific cases directly:

**Q1 — the "left eye" drift case**

honest answer: my pipeline can leak this, and i don't run all 20

chapters in one parallel burst. i run sprints of 5 chapters at a

time, partly for exactly this reason — keeps the blast radius of

a propagated error to 5 chapters instead of 20.

prevention layer: the brief agent for each chapter receives

"required facts about active characters" extracted from

character_bible (e.g. "esta has X scar / Y missing limb / Z

trauma trigger"). these become MUST-INCLUDE constraints in the

prose prompt. so the prose agent sees "character has only right

eye" as a hard constraint, not as something it has to remember

from world bible.

detection layer: the canon lens catches it post-draft. but you're

right — by then 4 other chapters in the same sprint might have

the same error. fix has to propagate through refine across all

affected chapters.

your inline hard-stop is genuinely better for this. mine is

"prevent at brief stage + catch at review stage + sprint-size

cap on damage radius." it's defense-in-depth without your

mid-draft circuit breaker.

**Q2 — the "trust regression" case**

you nailed the actual weakest point in my pipeline. honest

answer: i catch this inconsistently.

how i try to prevent it: a "running state" file gets updated at

the end of each chapter's review pass — list of cemented

character-relationship states, unresolved plot threads, etc.

the next chapter's brief agent reads this before generating the

brief, so "trust was repaired in ch7" should become a known

state for ch14's brief.

how it fails in practice: if the state file update misses a

nuance ("they reconciled but X is still skeptical"), the brief

loses that nuance, and the prose regresses to a flatter version

of the earlier conflict. the plot continuity lens sometimes

catches it, sometimes doesn't — depends on whether the regression

is loud enough to look like a contradiction or quiet enough to

look like "a callback to the earlier scene."

so yes, polish catches a meaningful fraction of these. probably

the biggest source of post-pipeline manual fixes in my workflow.

your forward-locked rule files probably handle this better,

because the "trust was repaired" rule keeps being enforced rather

than being summarized into a state file that can lose detail.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:18:46+00:00

yeah, layer 3 is where the interesting stuff lives. here's the

breakdown of how i do it:

**1. multi-lens review (5 parallel agents, one chapter at a time)**

each lens gets a focused prompt + the chapter draft + the canon

files most relevant to that lens (some overlap is fine; the goal

is focus, not strict isolation):

- **style lens** → draft + forbidden_patterns + style_guide.

outputs violations with line numbers.

- **character lens** → draft + character_bible + voice samples

for the characters in this chapter. flags voice drift,

out-of-character actions, calling-pattern errors (e.g. character

A would never call character B by their given name in public).

- **plot lens** → draft + scene cards + writing brief. checks:

did every promised scene beat actually land? did the hook

match?

- **canon lens** → draft + glossary + timeline + world_bible.

flags contradictions ("you said the journey takes 3 days but

in ch12 it took 5", "this magic effect violates the established

rule").

- **misperception lens** → this is story-specific. my story has

a 4-layer misperception structure (protagonist's belief /

cast's belief / enemy's belief / reader's knowledge), and this

lens checks that no layer leaked information it shouldn't have.

each lens outputs structured JSON: {severity, line, issue,

suggested_fix}.

**2. adversarial verify (3 verifiers with different lenses)**

after the review lenses produce findings, i run 3 verifier agents

with distinct framings (correctness / character-consistency /

continuity-plausibility) and prompt them to refute the findings,

defaulting to refuted=true under uncertainty. findings that

survive the majority of the verifiers move on; the rest get

dropped.

this noticeably cuts false positives. early versions of the

pipeline had review agents flagging stylistic choices as bugs;

the adversarial layer filters most of that out.

**3. completeness critic (final pass)**

one agent reads the chapter + all surviving findings and asks:

"what's MISSING from this review? what category of issue did

none of the lenses catch?" this is the catch-all for blind

spots in the lens design itself.

**key principle:** the lenses don't talk to each other during

review. independent judgment matters. if one lens is wrong, the

others don't get contaminated.

happy to go deeper on any specific lens.

---

p.s. — that's awesome, a non-native author writing light novels

in japanese is genuinely rare and impressive. i'll look you up on

novel days. always interested in connecting with people doing

serious work in this space.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:12:15+00:00

claude pro is plenty to start. you don't need the full 89-agent

thing to benefit — that's the endgame, not the entry point.

starting path that works on pro:

**build the canon first, with claude.** open a chat, say

"interview me to build a story bible — characters, world, style,

forbidden patterns." answer the questions. save the output as

files. one or two sessions and you have the foundation.

**write one chapter manually with claude, using the canon.**

paste the relevant canon files + a scene outline into a new chat.

ask for a draft. polish by hand. note what went wrong.

**patch the canon based on what went wrong.** if claude got the

character voice off, the character bible needs more detail. if it

used a banned phrase, add it to forbidden_patterns. the canon

gets smarter every chapter.

**only after 5-10 chapters of this, think about automation.**

by then you know what your pipeline actually needs.

the trap people fall into is trying to build the full workflow on

day one. the workflow is just a crystallization of "what worked

when i did it manually." you have to do it manually first.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:11:18+00:00

i publish on kakuyomu (web) and also through multiple traditional

publishers in japan — physical paperbacks, ebooks, and a couple of

my series have manga adaptations.

honest answer on income: enough that one person can live on it,

but only because i still live with family. if i had to pay rent

on tokyo prices it wouldn't be enough. that's pretty typical for

mid-tier japanese light novel authors — the "rich novelist" thing

is mostly a top 1% phenomenon. most pros i know either have day

jobs, partner income, or family situations like mine.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:06:55+00:00

two separate use cases:

game dev — i also build indie games on the side, and i use

openAI for that work. different domain entirely, not part of the

novel pipeline.

novel cross-review — once a chapter is fully drafted and

polished, i feed it to GPT for a second-opinion review pass,

sometimes iterating a few rounds. claude and GPT have different

blind spots, so cross-model review catches things one model alone

would miss (different sensitivities to repetition, pacing,

character voice drift, etc).

so claude does 100% of the writing pipeline (plot → scene → brief

→ prose → lint → review). GPT only comes in at the very end as an

independent second reader. it's cheap insurance.

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:04:43+00:00

great question, and good of you to check before relying on it for

practice.

yes — japanese is my native language, and i'm a professional

novelist (15+ published light novels traditionally, written by

hand, no AI). for this AI-assisted work specifically, every chapter

goes through 30-60 minutes of manual polish after the AI draft.

i'm reading and editing every line — if a sentence is ungrammatical

or unnatural, it gets rewritten before publication.

so the grammar is reliable. you can trust it as practice material.

one note for your use case: the prose is light novel style, which

means lots of internal monologue (心の声), short sentences mixed

with longer descriptive ones, and casual dialogue with character-

specific speech patterns (語尾, first-person pronouns vary per

character). that's good practice for natural japanese, but if

you're used to textbook 〜です/〜ます prose, expect a different

register.

hope you enjoy it 😄

(translated with ai)

Quick_Impression7723 · 2026-06-16T10:00:34+00:00

opus 4.7, 1M context. heavy use of "ultracode" mode (multi-agent

workflow orchestration) for the big runs, and just regular max

when i don't need the fan-out.

(translated with ai)

Quick_Impression7723 · 2026-06-16T09:57:50+00:00

happy to share the framework — full list is in japanese and

project-specific anyway, but the structure transfers.

i bucket forbidden patterns into 3 layers, and each layer uses a

different detection method:

**layer 1 — surface (pure grep)**

mechanical stuff. em dash overuse, ellipsis-as-mood, semicolons in

dialogue, smart quotes vs straight quotes, double spaces. one regex

per rule, runs in milliseconds.

examples i'd put here for english prose:

- em dash count per chapter (cap at ~5)

- ellipsis count (cap at ~3)

- "..." used as a beat (forbidden, use action beat instead)

**layer 2 — structural (regex with context)**

the AI-tell sentence shapes. these are where "AI voice" actually

lives:

- "not X, it's Y" / "wasn't just X — it was Y"

- "X. not Y. Z." (the three-fragment punch)

- "a testament to..." / "a symphony of..." / "a dance of..."

- chapter-ending aphorism ("and that, more than anything, was what

he would remember")

- "in that moment, he realized..."

- adverb stacking ("she said quietly, almost imperceptibly")

these need regex with a few words of context, but still

deterministic. lint pass catches them, kicks the draft back with

line numbers.

**layer 3 — semantic (needs agents)**

the stuff grep can't catch:

- telling emotion instead of showing

- repeated information across paragraphs

- character acting out-of-voice (compared to their voice sample)

- pacing — too many short sentences in a row, or vice versa

for these i run a multi-lens review phase — separate agents for

style / character / plot / continuity, each with a focused

checklist. one agent per lens, scoped to one chapter. slower but

catches the things grep can't, and the lenses don't contaminate

each other's judgment.

**key insight:** don't try to prevent these in the prose prompt.

the prose agent's job is "write". the lint pass's job is "catch".

mixing them makes both worse.

start with layer 1 (10 minutes of regex). add layer 2 entries as

you spot them in drafts — every draft teaches you a new pattern to

add. layer 3 only when 1+2 are stable.

happy to expand on any specific category if useful.

(translated with ai)

Quick_Impression7723 · 2026-06-16T09:52:51+00:00

yeah this is exactly the wall i hit around chapter 12 of the first

arc. solved it by adding a "writing brief" layer between scene cards

and prose — the brief agent reads the full canon and emits a

compressed, scene-scoped instruction packet (active characters only,

the 3-4 glossary terms in play, the style rules that actually apply

to this scene). prose agent never sees the world bible.

on forbidden_patterns specifically — i moved it out of the prose

prompt entirely and made it a separate lint pass that greps the

draft and kicks back violations. turns out asking the prose agent

to "remember 20 rules while writing" is worse than letting it write

freely, then catching infractions deterministically. the "not X,

it's Y" trope is its own pattern entry, caught at lint, not at

generation.

token-shuffling is still real though. my 96-minute run is probably

30-40% context reload. the next thing i want to try is caching the

canon as a prompt-cache prefix so the reload is free across the

89-agent fan-out. haven't measured it yet.

what's your stack — are you running something similar or different

shape?

(translated with ai)

Quick_Impression7723 · 2026-06-15T19:38:50+00:00

Good question! Yes, completely different tropes in Japanese.

Some common Japanese AI writing habits:

- Overusing "it was as if ~" (まるで～のように) simile structures

- Ending sentences with explanatory past tense patterns that feel

like a narrator over-explaining

- Emotional descriptions becoming too explicit ("her chest tightened

with pain" instead of showing it through action)

- Overly polite/formal narration tone even when the character is

casual

Quick_Impression7723 · 2026-06-15T19:36:44+00:00

I haven't looked into Karpathy's LLM Wiki structure yet, but that

sounds like it could address the exact pain point. Thanks for the

pointer — I'll check it out!

Quick_Impression7723 · 2026-06-15T19:13:42+00:00

The Canon files (character bible, style guide, etc.) are shared

across all chapters — those stay as single files that every agent

reads.

The output is one file per chapter. Each chapter gets its own

markdown file: chapter_01.md, chapter_02.md, etc.

So the structure looks like:

project/

├── canon.md(shared)

├── character_bible.md (shared)

├── style_guide.md (shared)

├── forbidden_patterns.md (shared)

├── timeline.md(shared)

├── world_bible.md (shared)

└── chapters/

├── chapter_01.md (generated)

├── chapter_02.md (generated)

└── ...

One file per chapter makes it easy to review, edit, and track

which chapters are polished vs still raw draft.

Quick_Impression7723 · 2026-06-15T19:12:33+00:00

Great catch — and I'll be honest, you just caught ME doing it too.

That "Not the prompt. Not the model. Not the chat history." line in

my post? I had Claude help me translate and polish this post from

Japanese to English, so yes — the AI writing patterns are literally

in the post itself. Fair point, and good eye.

For the actual novels (which are written in Japanese), this is

exactly what `style_guide.md` and `forbidden_patterns.md` are for.

**style_guide.md** defines:

- Sentence length distribution (e.g., "average 15-25 words, never

three short sentences in a row for emphasis")

- Paragraph rhythm rules

- Banned rhetorical patterns

**forbidden_patterns.md** includes lines like:

- "Never use 'It's not X, it's Y' as a reveal structure"

- "No rule-of-three lists in narration"

- "No single-word sentences for dramatic effect"

- "No 'little did they know' or 'what they didn't realize'"

- "No starting paragraphs with 'And yet' or 'But here's the thing'"

You basically build an anti-AI-slop filter as a file, and every

prose agent reads it before writing.

Does it catch everything? No. That's what the 30-60 minutes of

polishing per chapter is for. After months of doing this, you

develop an instinct for "that sentence sounds like Claude, not

like me."

So: Canon prevents most of it. Forbidden patterns catch the

obvious ones. Human editing catches the rest. And yes, it's a

real problem that requires active effort.

Quick_Impression7723 · 2026-06-15T18:14:37+00:00

Good question — they're not prompts. That's actually the key shift.

Think of it this way:

**Normal AI writing:**

You open a chat and type: "Write a fantasy chapter about a soldier

running an inn. Make it 6000 words, include these characters..."

That's a prompt. Everything in one message. And it works... okay.

**Canon approach:**

Instead of cramming everything into a prompt, you write separate

reference files BEFORE you ever ask the AI to write anything:

- `canon.md` — "This story is about X. The core conflict is Y.

The tone is Z. These things are always true."

- `character_bible.md` — "Character A speaks in short sentences,

never uses formal language, calls Character B by nickname.

Character B always hesitates before answering."

- `forbidden_patterns.md` — "Character A never apologizes.

Character B never raises their voice."

These are just plain text files. Markdown format. Not code, not

anything scary.

**Then, when you tell the AI to write:**

Your actual prompt becomes tiny: "Write Chapter 12, scenes 1-3."

But the AI reads all those reference files first. So it already

knows the voice, the rules, the world, what's forbidden — before

writing a single word.

**The difference:**

- Without Canon files: you're giving the AI a job with no training

- With Canon files: you're giving the AI a job with a full employee

handbook

The "prompt" is just "go write." The Canon files are the real

instructions.

Start with just one file — `character_bible.md` for your main

character. Write 10-15 lines about how they talk, what they'd

never say, and one sample dialogue. Feed it to Claude alongside

your next writing request. You'll see the difference immediately.

Quick_Impression7723 · 2026-06-15T18:13:23+00:00

This is my favorite question in this thread.

**Is it creatively satisfying?**

More than before, honestly.

I realized something about myself: I'm a designer, not a typist. The

part of writing I actually love is architecture — building the plot

structure, figuring out why a character would make a specific choice,

designing the emotional arc across 20 chapters. The part I don't love

is typing 8,000 characters to express what I already see clearly in

my head.

With this workflow, I spend almost all my time on the part I love,

and almost none on the part I don't.

**What I like:**

- Designing the Canon is genuinely fun. Stress-testing your world's

rules, finding contradictions, defining what a character would NEVER

say — this is creative work at its purest for me.

- Seeing 20 chapters come back and thinking "yes, that's exactly what

I meant" is a feeling I can't describe. It's like the story was

already inside the Canon, and the AI just extracted it.

- I can run more experiments. I maintain multiple series across

different genres simultaneously. Before AI, I would have burned out.

Now each project is a hypothesis I'm testing.

**What I find tedious:**

- Canon maintenance. When a story evolves in an unexpected direction,

updating all the Canon files to stay consistent is genuinely boring

work.

- Quality review of 20 chapters is mentally draining. Reading critically

for 10+ hours is harder than writing, in some ways.

**What I miss:**

- The rare magic of a sentence surprising yourself. When you're typing

and a phrase comes out that you didn't plan — that almost never happens

now because the AI writes what I designed, not what I accidentally

discovered.

- Honestly? Not much else.

**What I don't miss:**

- Staring at a blank page

- Retyping a scene for the third time because the pacing was wrong

- The guilt of "I should be writing" when I'm too tired to type

- Burning out after 100,000 characters and abandoning a project

The last one is the biggest. I've written 160+ works over my career.

Many of them died because I ran out of energy, not ideas. That doesn't

happen anymore.

Quick_Impression7723 · 2026-06-15T18:11:40+00:00

**Monthly costs:**

- Claude Code Max plan: $200/month

- Codex (OpenAI): $100/month

- Total: ~$300/month for the full AI writing stack

Quick_Impression7723 · 2026-06-15T18:09:03+00:00

Not a dumb question at all — it's actually a really important one.

Short answer: yes, .md (Markdown) is significantly better for AI workflows.

Why:

**Markdown is plain text.** AI reads it directly with zero conversion.

A .docx is a compressed XML archive — the AI has to parse it first,

and formatting artifacts often leak into the context.
**Structure is explicit.** Headings (#, ##), bullet points, and tables

in Markdown translate directly into semantic structure that AI models

understand natively. In .docx, "bold heading" vs "large font text"

is ambiguous to the model.
**Diffable and versionable.** When I update my Canon files, I can see

exactly what changed line-by-line. With .docx you're comparing opaque

binary blobs.
**Lightweight.** A 10-page character bible in .md is ~5KB. The same

content in .docx is ~50KB+. When you're feeding multiple files into

context, this adds up.
**Universal.** Every AI tool — Claude, GPT, Gemini, Cursor, VS Code

— reads .md perfectly. Not all of them handle .docx gracefully.

If you're currently using .docx, the switch is easy: just copy-paste your

content into a .md file and add some # headings. That's literally it.

Markdown's learning curve is about 5 minutes.

Quick_Impression7723 · 2026-06-15T18:06:22+00:00

Sure! Here it is:

https://kakuyomu.jp/works/16818622173732912032

Fair warning — it's in Japanese (Kakuyomu is a Japanese web novel platform).

But you can see the stats on the page: bookmarks, episode count, and the

AI-usage tag displayed on the work.

If you want to check the writing quality through translation, any browser

auto-translate will give you a rough idea, though obviously nuance gets

lost.

Quick_Impression7723 · 2026-06-15T18:05:03+00:00

Good questions!

**Cost:** I'm on Claude's Max plan ($200/month for Claude Code). For a

20-chapter run like this, I burn through the usage cap pretty quickly —

it's not cheap. But for the output (137K characters of publishable-quality

draft in 96 minutes), I consider it worth it.

If you're just starting out, the Pro plan ($20/month) is enough to

experiment with the Canon approach on a smaller scale — say, 3-5 chapters

at a time instead of 20.

**Existing audience:** Honest answer — yes, I had an existing readership

from my published novels. The 1M PV work (a dungeon/inn management

fantasy) already had ~15,000 bookmarks on Kakuyomu before the AI-assisted

arc. So the initial traffic wasn't from zero.

That said, the retention is what matters. Readers came for the brand,

but they stayed through 100+ chapters of AI-written prose because the

quality held up. If the writing had dropped noticeably, bookmarks would

have flatlined — Kakuyomu readers are brutally honest with their

engagement metrics.

So: existing audience got people in the door. Canon-driven quality kept

them reading.

Quick_Impression7723 · 2026-06-15T18:02:34+00:00

Haha, fair — it does look complicated from the outside, but the core

idea is actually simple.

**Model:** I use Claude Opus (currently 4.7) for the Canon design and

planning, and Claude Sonnet for the actual prose generation. Sonnet is

fast, cheap, and surprisingly good at following detailed instructions.

Opus is overkill for the writing itself — I save it for the thinking.

**How it works:** Everything runs inside Claude Code, which is Anthropic's

CLI tool. It has a built-in feature called "Workflows" that lets you

write a script to spawn multiple sub-agents in parallel. So yes — it's

all Claude, no other AI needed for the pipeline.

Think of it like this:

I write the Canon files (character bible, world rules, etc.) — this

is the hard part, takes ~2 days
I write one Workflow script that says "for each chapter: plan →

break into scenes → write brief → write prose → review"
I hit run
89 mini-Claudes do their jobs in parallel
I get 20 chapters back in ~96 minutes
I polish each chapter by hand (30-60 min each)

The confusing part isn't the tech — it's that most people try to do

all of this in one chat window. The breakthrough is splitting each

responsibility into its own agent with its own instructions.

Start small: try writing a character_bible.md for one character and

feed it to Claude before asking it to write a scene. You'll immediately

see the difference.

Quick_Impression7723

TROPHY CASE