AI was better at writing in 2023

It was more profitable in 2023, not better. Also, back then a good number of people (including writers), could not identify AI-isms and AI writing patterns.

You're write about flooding the market though. That has been the model for Amazon since many years ago, just that back then people had to write the books themselves or outsource it.

We (yes, I did this myself), were limited by our talent, our time, and our budget. With AI, the barriers to entry have been lowered to the point where anyone can do it and people have jumped on the bandwagon in large numbers.

Do you just publish and move to the next? Or do you also spend on ads or other promotions? (If so, could you share what else you're doing?)

I've got books up but most of them barely sell a copy a month. (I've got over 250 books and I've got 202 sales this year so far).

Sure, the only tool I use is Anti-Gravity. It's an IDE that allows you to access files on your computer and a LLM like Gemini or Claude.

I then use workflows to manage the writing process, and information files to control what data the AI does and does not have access to.

The details are kinda long, so if you'd like to learn more you can review my previous comments (click on my username). I detail more about how I build and structure my workflows there.

The major differences between my own system and ConWriter is that ConWriter classifies consistency errors into 5 categories and 19 subtypes, things like Timeline Contradiction, Abandoned Plot Element, Geographical Contradiction, Knowledge Contradiction, and so on.

My system catches most of these implicitly through audits and gates, but there's no shared vocabulary across agents. If one of my Agent flags something and another of my agents flags something, they're not using the same classification language, which makes it harder to track which error types are recurring.

What I already have (and it maps well)

Static and dynamic memory split

My planning docs (brand, series structure, world bible, tenets) function as static memory, things that never change. My handoffs, entity index, and chapter packets function as dynamic memory, tracking what has changed chapter by chapter.

ConWriter calls this the same thing, so the architecture is conceptually aligned and I think this is a good foundation for any writing system.

Incremental, stateful generation loop

My workflows already do exactly what ConWriter describes: build a state bridge, compile a context packet, draft, audit, polish, verify, then update state before the next chapter. ConWriter just calls it an "incremental scene-by-scene loop." Mine runs at chapter level rather than scene level, but the logic is the same.

Strong structured validation

My logic audits, tenet enforcement, entity index checks, banned pattern lists, and PowerShell validators cover most of what ConWriter calls "structured consistency checks". The enforcement is there, it's just spread across multiple agents and gates rather than organized under a single named taxonomy.

What I do not have

An explicit state transition object per scene

ConWriter defines each scene with a formal Pre / Post / Forbid structure:

What must be true before the scene runs What must be true after it completes What is explicitly forbidden from happening

My system has the equivalent of this spread across 4 broad categories, but it's not bundled into one object that an agent can check cleanly in one place. A centralized error tracker would be a time (and token) saver for me.

A risk-based uncertainty monitor

ConWriter has a second validation channel that focuses extra scrutiny on "high uncertainty" segments, passages where the model is statistically less confident. My gates are all rule-based and treat every part of a chapter equally. There's no mechanism that says "this paragraph looks shaky, audit it harder."

I think this is one of the main areas where I can see improvements to my system.

Sentence-level patch repair anchored to violations

When ConWriter finds a problem, it patches only the specific sentences that contain the violation, using the violation itself as an anchor. My Writing agent does targeted passes (dialogue, sensory, mechanical), but those passes are driven by general rules rather than "fix sentence 14 because it contradicts the world bible entry for X."

A dynamic experience bank per model

ConWriter builds a bank of known failure patterns per base model and feeds those back as soft hints during future runs. My tenets and banned lists are global and static. They don't learn or update based on what went wrong in previous chapters or previous books.

Honestly, I only ever write with one or two models and I'm not sure if building such an experience bank is a worthwhile use of time on an individual level.

External benchmark and error density metrics

ConWriter is calibrated against a 2,000-prompt benchmark and tracks Consistency Error Density (errors per 10k words). My system has an internal test plan and gate pass rates, but nothing that lets me compare my output quality against an external standard or track error density over time.

Again, this is not something that I think is beneficial at the individual level. I only have so many prompts, errors, and benchmarks.

The way it does this is through a repository of a list of logical consistency rules (theory of mind, things that have already happened in the world, everything needs to be justified), and compressing to the necessities as it goes along and referencing as necessary (pulling into context).

This approach is similar to what I've been working on except I'm on Antigravity instead of Claude Code.

The list of logical consistencies I use are formed from several files and are vetted by myself before the writing process begins.

The thing about this approach is that you need to have a number of preperation steps, verification steps, and compliance checks at various points of your process. This can slow down and bloat the cost of production, which is why I'm looking for alternatives. (Check some of my earlier posts if you're interested, I've detailed my system there.)

I'll 3rd this. Having an IDE (Integrated Development Environment) such as Claude Cowork, Claude Code, or Google Antigravity allows you to better manage information.

To specifically address OP's issues of consistency, I use my IDE to incorporate checks and controls at each step to ensure compliance to my stories, lore etc.

This make the writing less of a "creative" process and much more of a technical/operational process. This means that if the AI ever writes "out of scope", makes up facts that do not align with the brief/character outlines etc, the output does not pass the check and the process is started over again.

This does mean that you will not reduce token usage and improve consistency. It's mutually exclusive, and I have only managed to achieve one while sacrificing the other.

The result of the Amazon market study is a classic oversupply problem. More books competing for the same reader attention means lower average returns per title, and that pressure is showing up across the whole category, not just in AI-heavy titles.

Most imporantly: "Revenue per selling title fell across cohorts, and books with no detected AI text saw the same downward trend."

This matters for publishers because the economics of genre fiction have historically rewarded catalog depth and consistent release cadence. AI tools are now putting that same strategy within reach of individual authors at a fraction of the cost, compressing margins for everyone and making discoverability harder to maintain.

The publishers best placed to navigate this are the ones treating it as a positioning and audience problem rather than purely a volume problem. Readers are still spending, they are just spending more selectively in a noisier market.

As an author or publisher, how are you thinking about positioning and differentiation in a market where supply is growing faster than demand?

Yes, it's a 2 pass approach. The AI can't write what isn't in the files it has access to.

As for the truths that you want the characters to know but not the reader, I don't know? I never had to do that before. I would try putting that in the prompt or in a template somewhere, or edit it in the editing phase.

Could you share more details on your process and maybe I can give you some feedback?

Hello! Sure, I'll be happy to answer any questions I can.

As to your question about "knowledge" I have a "pre-flight checklist" that I get an agent to create. This is based on past chapter(s), notes, character profiles, etc.

This checklist includes a list of topics that can and cannot be mentioned. For example, I might have a section to mention that "John and Jane have already resolved their disagreement about X. They have agreed Y.".

Things like secrets or future plot twists are prohibited from the AI in this checklist and are not mentioned at all. The rest of the agents are told to ONLY work off this checklist, and a new checklist is generated for each chapter as I go forward to add any new information. This means that the checklist also contains the beats for the chapter, the character details that are necessary for the chapter etc etc.

All the other agents working on the chapter are to treat this document as the single source of truth for the chapter, and this overrides any and all other documents when writing the chapter. This is to prevent any leaks, misalignments, or deviations.

I believe that it has to be caught in the pre-generation of each chapter as you cannot plan these little details in advance. To catch it on an audit pass requires a lot more attention to small detail, which the AI is usually incapable of, given the size of a novel. A human may also miss these.

How my system catches these:

The missing-eye / wrong-detail problem

This is a world-rule problem, not just a prose problem, so it gets checked at multiple points instead of one:

Canon gets compiled into locked rule files before any drafting starts, so the "world facts" are frozen early

The agent that writes prose only works from a pre-built prompt packet, it's not supposed to invent its own continuity

A logic audit step compares the draft against the blueprint specifically looking for drift, including physical/timeline details

A structural compliance check explicitly verifies lore and entity accuracy before a chapter can be finalized

A final verification step is the last checkpoint before the chapter gets locked in

So in the eye example, that should get flagged by the audit + compliance check combo, not by someone happening to notice it during polish.

Honest weak point: if the wrong detail gets repeated across several chapters before a gate catches it, it can still propagate a bit. The system is built to catch it, but not guaranteed to catch it on the very first occurrence unless that specific canon detail was pulled into that chapter's context.

The regression / rehashed conflict problem

This is a state-tracking problem across chapters, handled by a different layer:

Each chapter gets a "bridge" built from the previous chapter's outcome plus the blueprint, so it knows what's already changed

Only the relevant canon and character state gets pulled into that chapter's packet, not the whole story history

A continuity step explicitly updates a master record after each chapter, tracking relationship changes, resolved threads, and inventory/state shifts

Before promotion, the chapter gets checked against that master record and the blueprint

So if chapter 7 resolves a trust issue, chapter 14 shouldn't get drafted as if that resolution never happened, because the carried-forward state is supposed to flag that relationship as already changed.

Where it gets fuzzy: there's a real difference between a hard contradiction and a soft regression.

Hard contradiction: chapter acts like the resolution never happened. This is exactly what the state/continuity checks are built to catch.

Soft regression: the resolution is technically acknowledged, but the conflict gets recycled anyway and just feels stale. This is more of a judgment call, caught by creative review and polish passes rather than the strict logic check.

So plot continuity should catch true regressions reliably. A thematic rehash without a strict state violation is more likely to need a human eye, same as it would in your system.

tl;dr

Both of these get split across different checks instead of relying on one pass to catch everything: one set of checks for "is this specific detail accurate" and a separate set for "is the story's actual state being tracked correctly between chapters."

The eye example is a detail-level bug, the trust-issue example is a state-level bug, and the system treats them as genuinely different problems rather than hoping one continuity pass at the end catches both.

you're

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

Yup, you've nailed it! The reason I spent so much time crafting the safety mechanisms like my stateless protocol (focus only on one task per prompt), the character state inventory, the dialogue inventory, and then running checks on the final vs draft vs blueprint is to prevent these issues with AI.

Thank you for your honesty. Your system sounds great but I was wondering about the above 2 issues since these are the biggest issues I've had to work around.

My solution may also be more "safe" and compliant but it comes at a huge cost. Running prompts means I max out my tokens even though I'm on the paid plan. I have to stop after 2 or 3 chapters and continue later in the day.

Lastly, I want to suggest you to look into a "stateless" agent at each stage of your prompts. So each prompt is executed ONLY from a specific prompt packet.

So if you're drafting 5 chapters, you would make each of the 5 chapter prompts with the information for each of the 5 chapters, then use each packet and tell your AI to only use information in that prompt.

The prompt pack will contain all the information like the relevant parts of the character.md the worldbuilding.md and other parts ONLY. So things that are not relevant like characters or events that are not in the chapter are not called. This will prevent a lot of the AI drift.

You can then run checks on your final chapter vs. the prompt packet for each chapter to ensure compliance. I hope this helps you!

If you choose to do this, please let me know how it goes.

Edit: I added more detail on my system here - https://old.reddit.com/r/WritingWithAI/comments/1u6g6e4/published_novelist_15_fantasy_books_1m_views_on_a/os11law/

I built an AntiGravity system to address those very issues you're tackling. The difference is that while you're running the checks on a full manuscript, I took the approach to check as the manuscript is being written. One chapter at a time, and before proceeding to the next chapter.

I've tried your approach before, but I found that inconsistencies and details are punctuated across chapters and compound as more and more of the manuscript is written. Therefore, I chose to address this one chapter at a time.

Issues of pacing, contradiction, hallucination, and malcompliance with plot and characters compound over time and are written into the story as more and more of it are developed with AI.

I think what you're doing certainly has value, but it is most useful for those who do not use an IDE or advanced writing system. For people who use prompts or write without AI, it would definitely be a benefit.

As an AI author these issues need to be addressed as your manuscript is written otherwise it would be too much of a mess to correct later on.

Yup, I've built something similar.

The way I would approach this is to feed the AI the information and give it your goal. Then ask the AI to lay out the steps and explain the structures to you. Lastly, you can start recreating it.

Having done something similar myself, this is a process that takes hours of refinement and edits. You will find mistakes, non compliance, misalignment between the prompt and your vision, etc.

I myself went through over 50+ interations before I was satisfied. The file system ended up with:

• 8 active workflows.
• 11 agent skills.
• 36 with another 15 renames and decommissioned.
• 4 Powershell validation scripts.
• 5 major user-facing planning docs plus 2 compiled context binaries, with the lore system adding templates and entity files.
• 3 documented override exception types.

Thank you for sharing! I really enjoyed your breakdown. The four-agent pipeline plus the four-axis review is clean, and 137,806 characters in 96 minutes is a great proof point for "AI replaces the typing, not the writer."

I built something similar in spirit, canon locked, AI only allowed to execute, not invent, but the shape turned out pretty different. I'm using AI to compare and I am sharing for comparison.

Quick comparison

Canon files

Yours: 7 files (canon, character bible, glossary, timeline, world bible, style guide, forbidden patterns)

Mine: Blueprint + World Bible, then compiled into separate rule files that the writing AI reads

Chapter pipeline

Yours: 4 agents (Plot → Scene Cards → Brief → Prose)

Mine: Long chain of single-job prompts, split across multiple specialized agents

Review timing

Yours: After all chapters are drafted

Mine: Inline, per chapter, before it moves forward

Can it halt mid-process?

Yours: Not really, loop back after review

Mine: Yes, hard stops on rule violations

File saving

Yours: Not specified

Mine: Locked in by a script, not the AI, so it can't be hallucinated wrong

Best at

Yours: Speed, parallel drafting of a whole arc

Mine: Catching problems before they spread

How the pipeline works

• Canon stage*: a blueprint and world bible get written first, same as your canon files.

• Compile step: those get turned into separate "rules" files. The agent that actually writes prose never sees the original blueprint, only a prompt that's already been filtered through it.

• One job per agent: instead of one agent doing planning, voice, and dialogue, each task gets its own specialist (one for logic checks, one for prose style, one for dialogue, etc.). The idea is mixing too many jobs in one prompt is where drift sneaks in.

How it catches problems

Instead of reviewing after the fact, mine checks things while the chapter is still being built:

• Logic check — compares the draft against the blueprint, can stop the whole process if something doesn't match

• Length check — if a chapter comes in short, it goes through an expansion step before anything else touches it

• Compliance scan — checks POV, lore accuracy, pacing; a failure stops the pipeline outright instead of letting it slide through

• Locked saving — final files get saved by a script, not by the AI, so there's no risk of a save going wrong

There's also a manual override option, but it requires explicitly flagging it with a reason, so nothing gets skipped by accident.

Where your system wins

Honestly, the parallel drafting. Running the same pipeline across 20 chapters at once is a real speed advantage I don't have, mine runs more sequentially per chapter, so once canon is locked, you're scaling faster than I am.

Mine probably has an edge for long series, since canon carries forward more cleanly across multiple books, and catching issues mid-draft means less cleanup later.

---

Genuinely curious: without something checking mid-draft or locking files automatically, how do you catch a chapter drifting from canon before it's fully written, or a bad save, before it spreads across all 20 chapters running at once?

For example, say your world bible establishes a character lost their left eye in chapter 3. If the prose agent in chapter 12 describes them noticing something "out of the corner of her left eye," that's a quiet contradiction that's easy to miss in a 20-chapter parallel run, since nothing forces a check against the world bible mid-draft. By the time the world continuity review catches it (if it catches it), eight more chapters might already reference the same eye incorrectly.

And separately: how do you catch continuity issues like a plot thread getting rehashed instead of advanced, or a development that's supposed to stick not actually sticking?

Say chapter 7 has two characters resolve a trust issue and explicitly move past it, but chapter 14's brief doesn't carry that resolution forward, so the prose agent writes them right back into the same suspicion and arguments as if chapter 7 never happened.

Since each chapter pipeline doesn't necessarily know what got cemented earlier, does the plot continuity pass reliably catch that kind of regression, or is that something you end up spotting yourself during polish?

I'm surprised his name isn't Marcus Chen. 😂😂😂

Seriously though, good job!

I "write" with AI frequently, and yes there are very obvious tells if you know what to look for. Individually, any one of them is not a giveaway, but if you do see too many of them in a piece of writing that's your giveaway.

That being said, most people are indeed unable (or don't care enough) to differentiate AI writing from human writing.

It’s hard to draw a clean line between “pure” writing and tools that assist writing, because the industry has always included highly structured, high-output genres.

Some corners of publishing already prioritize consistency, speed, and meeting audience expectations over singular artistic voice pre-AI. Pulp fiction, category romance, and rapid-release thriller/mystery series are good examples.

These spaces I mentioned above often rely on familiar frameworks, recurring tropes, and plot-first storytelling designed for readers who want a dependable experience. That doesn’t make them bad. It just means the goals of the writers are different.

The craft is often about execution and productivity as much as personal expression.

Given that environment, it wouldn’t be shocking if some writers are already experimenting with AI as part of their workflow: outlining, drafting filler passages, brainstorming twists, or accelerating revisions. Readers may not even notice when the end product still satisfies the genre’s expectations.

The idea of “writing as art” absolutely applies, but it applies unevenly across the publishing ecosystem.

Some books are intimate personal statements.

Others are commercial entertainment built on recognizable formulas.

Both exist, and both have their audiences.

AI is more likely to slip into the latter first, because the structure of those markets rewards efficiency and scale. Talent or art has a lot less to do with the tools of choice (and yes, AI is a tool IMO) in those genres.

I use AI a lot in some of my work and I am familiar with "AI-isms" and identifying them. Even then it's not a 100% certainty that any of those signs means it's AI written or AI assisted.

Enough of them may raise suspicions but there's no way to 100% prove it.

That being said, I've seen many novels and webnovels with steallar reviews with those same AI patterns. For privacy of those authors, I won't name any names.

If you don't wanna take my word for it, look for the ZDNet article titled "Writers voice anxiety about using AI. Readers don't seem to care". There's a link to a professional survey done by Microsoft.

There's some limitations to that study, but the bottom line is that it seems to be a vocal minority that are the ones up in arms. So like I always tell my partner (who is also publishing), "just shut up and write, let the cheques do the talking for us."

Sawdust in food makes it a health risk.

What risk does AI in a piece of writing carry?

Some consumers may care, others may not.

Some authors may disclose, others may not.

But whether it is a consumer's RIGHT to know how much AI is in a text at the moment, it absolutely isn't at the moment from a legal standpoint, and to the best of my knowledge.

If asked, I sure as hell wouldn't give an answer either way.

Do you mind sharing the sources of research?

I have found narrators for as low as $40 PFH and the sky's the limit when it comes to cost.

What benefits do the more expensive narrators give? And is it worth the 5x premium or more? This is a business and I need to justify the cost, otherwise it wouldn't make sense to me.

Novelcrafter may be the tool you're looking for. I've used it before and it has a very well integrated codex for keeping track of people, places, and lore.

Hope it helps you out.

What kind of books are you publishing? Non fiction, fiction etc?

I've been pushing out books and yeah I sell more but it doesn't move the needle much.

Over 200 books. I was making close to $1k a month at one point, now it's dwindled down to about $150 a month.