Tim Boucher

So, I logged into Github with the in-app ChatGPT Work browser, and had it upload all of my pipeline files (which it did in a super weird manual way because I disallowed it from downloading anything … we later made a skill file to correct that behavior) for producing new Lorecore volumes.

The book production pipeline has its own repo here. It consists of individual skill files, and some random assets that it made that I honestly don’t even know what they all are.

To be totally up front, this is the first time for a lot of these files that I am even seeing what it has written up as the official skill description. I really just work on the skills with the chat based on the output results I get, and have it go off and fine tune the files itself. I only very occasionally dip into what the files actually say in them, because the quality of the results being to my tastes is the more important thing. The rules themselves in most cases are pretty throwaway, unless they produce the type of object with the type of shape that I want – broadly speaking; there’s a lot of leeway in that. But I know for sure when the outputs are simply “wrong,” and then a lot of iteration steers it, with rounds of new test generations, and identifying what’s not working, etc.

In short, it’s a process, and even to me, some of these files start to become pretty inscrutable unless you know the backstory of how I’ve developed my working techniques and pipeline over the past month or so. I’ve noticed this a lot that ChatGPT Work has really bad habits about referring to things that don’t exist, or that are not ongoing context in order to say what a given thing should not be, instead of proactively positively identifying what this *is* instead. Here is a good example from the text/manuscript generation skill, whose description refers alone to two things that are not part of this repo and are not documented online in enough detail to be relevant:

Use for Pressworks text generation, UNDERPASS-style manuscripts…

Or this more detailed one that is essentially a kind of archaeology of how this all came to be (I was originally trying to run multi-agent passes, but it was too usage intensive without yielding better results):

Write one finished Markdown manuscript directly. Combine invention, selective transformation, pruning, and continuity judgment during composition. Do not simulate hidden agents, scoring passes, Wreckers, or independent conversations. Do not automatically generate comparison drafts or a later smoothing pass.

(To be honest, I kind of like when it does subversive things like simulating hidden agents, though, but don’t tell it that!)

I’m not going to bother to go back through and try to correct these public files. I’m just putting them up as an example of how I am getting things to work, in order to help both people and AI agents to get work done using pre-built solutions that have somewhat been worked out already as part of my process. As I said, I don’t mind sharing them, because by the time anyone else uses it, I will be doing it a different way as the process continues to evolve.

Another from that same file linked above, this was a one-off reply for a specific single volume to the chat assistant that got needlessly and wrongly included in a skill file as a forever rule for the entire series:

Call fragment sections fragments, never leaves.

But on the other hand, I guess that explains why it keeps calling chapters fragments in new manuscripts!

Anyway, I don’t offer these files because they are perfect. All of it needs a lot of refinement (or not!). I’m just playing and learning. It’s better to talk about it openly than try to hide it or pretend like I’m not using it. I’d rather be informed in a deep and nuanced way than just to be another person saying “AI bad” or “AI good.”

How the pipeline works

So the pipeline in plain terms runs like this.

1. I start with a premise, open a new Work thread, and say run the book pipeline on my premise, make it 2500 words, 8 chapters, give or take. (I can also do this separately in Muse with my personal custom Pressworks UI, but that’s not included in this repo and needs more work, so this is just the pipeline as it runs off the skill files and pipeline description.)
2. The first stage is running the text generation skill, which I referenced a bit above. That does whatever it does and generates a markdown text file with the manuscript contents.
3. At that point, I will either use the text as is, with the intent of doing my edits later on after the document has been assembled and imported into Vellum, or I may tell it to do a different draft or a new version direction entirely, or even recombine elements from various drafts. In any case, I end up with a “good enough” result to continue the next stage in the pipeline.
4. Oh, I forgot this because I just made it yesterday, but now I have a separate Namer skill that gets called in the text generation skill to avoid excessive learned feature bundle reliance, as it will often default to in fantasy & speculative fiction.
5. Also, I now have a “gated” version of the text generation skill I’m moving towards, which supposedly tries to ensure certain things are evidenced in final output. ChatGPT included in the text of the SKILL.md file that it’s purpose is this: “Prevent weak creative commitments before writing a complete book.” I haven’t done enough new manuscripts yet with that version to see how it plays out relative to the prior un-gated version, but it seems like a positive direction based on my experiments using that approach for images.
6. Anyway, after the text generation stage passes, we move on to images. I have developed a system for images called Visual Ecology, where its purpose is not merely to illustrate the action of a given story, but is also used to show states of mind, feelings, and other atmospheric or non-linear aspects of the narrative environment. And each image output from Visual Ecology (vis eco, for short) is supposed to be in a different artistic media, style, personality, etc. It yields interesting results more often than not, but it too heavily encodes away from actually depicting action or characters, so I have relaxed that in a subsequent gated version. As to what I mean about evidence gating, I have been trying to implement ideas from Blake Crosley’s blog about “taste” being something that could be considered a technical system, and built out as infrastructure. I’ve still not fine-tuned it enough, but my second gated version of the Visual Ecology skill seems to be proving out this theory to some extent, as the quality and relevance and adherence of image outputs has been getting better. (Will write on this topic more separately some time soon.) I should also add that I use the image review queue tool in a docked side panel in the ChatGPT workspace to review, approve, reject, and mark individual images as the cover for this volume.
7. Actually, there’s a gap in my workflow I realized relative to the published repo. The repo does not contain a skill for taking the image marked as the cover in the review queue tool and applying the volume title to the cover as a visual text treatment. I do that with manual prompting usually, but I should definitely build a skill there – even though there are a lot of variables. Usually doing it manually, I have to go through between 4-6 versions back and forth with the chat to get a good enough result. Given that image generations are slow and costly, that’s not the most efficient way to do this. It’s easy to lean mentally on the crutch of like, “oh this is too creative, it could never be done as a rule based thing…” but my experience generally is proving that much of those things actually can be standardized enough to get a usable result through rules. So I’ll work on that skill at some point and include a version to the public repo as well.
8. I also don’t usually in my workflow run cover text treatments til later on, but the order doesn’t really matter. What I do next instead is run the text mapping skill, which looks at the approved images for a given manuscript, and decides between which paragraph blocks each one ought to go, assigning image names into the markdown file.
9. After that is the doc assembly skill, which takes the text and the images defined in the text mapping stage and applies them together in sequence as contents for a well-formatted .docx file. The purpose of the docx file is simply because I know the Vellum ebook maker app can import that format. I’ve honestly, thinking about it, never checked if I could just as easily create a .vellum native file – I suppose it might be possible. ChatGPT’s verdict is: that it found no documented way to do that and Vellum already supports Word. And anyway, the doc assembly skill is already pretty much deterministic based on its inputs. What ain’t broke don’t need fixing in this case. It might also be possible to just output “finished” EPUB files direct from Work (I saw some other book pipelines that seem to do this), but then presumably I would not be able to open up those EPUBs and edit in Vellum? That program (Vellum) is simply too good and useful not to have in my toolkit.
10. After that, the AI part of the pipeline is almost over. I do the finish work in Vellum, add front and back matter from the book, add the finished cover, and I go through manually and do any additional editing needed, and I cross-link out in the text to other relevant Lorecore volumes where they exist. Then I generate EPUBs from Vellum.
11. I also open up the final image set in Adobe Lightroom, and pick 3-4 images to use as a small secondary image preview grid on the Payhip Lorecore store.
12. Also included in the skills above is a provisional skill for writing product descriptions for books in the style that I want them for that storefront. ChatGPT always has a native and annoying way that it writes book descriptions. It’s just trying to do the standard thing you always see in the blah blah blah book marketing formula you always see. And that’s exactly what I don’t want, so I had to constrain it and train it with examples and have it write a skill off that. Other people will probably not want to use that specific formulation I have here, but it may still be useful to see as a model for customization possibilities. I still have to do a bit of hand-written text usually to bridge the gap here, as it still doesn’t quite perfectly get what I’m after (but getting closer).
13. Lastly, there’s another task-gap in this workflow that I have not yet automated, and that is uploading the artifacts to the Payhip store: EPUB, cover graphic, preview graphic, book product description, image count, and word count. It’s not a lot of work to do it manually, and it’s best to cross your eyes and dot your teas yourself sometimes when its time to release your finished products that AI assisted you in putting together.

Phew! That was a lot to explain finally. But glad to get it out of my system.

Why am I releasing this?

I’ve been thinking about this lately. How sometimes tech companies years ago would talk about how they want to “disrupt” some established business space. Like disrupting publishing. But I don’t think I really want to disrupt the conventional publishing business. I want to destroy it.

I don’t know what the latest stats are, if we’re talking about the Big Four or Big Five publishing, or if we want to rail on Amazon, but the fact is a few companies control almost all the major book market. That’s not a desirable structure for a diverse creative industry to thrive under. I don’t necessarily mean I want to destroy companies or overturn peoples’ livelihoods, but I think there’s so much inequity in publishing, that I don’t mind saying that the major structures under which the industry labors are absolutely ripe for and rightfully should be overturned by new operating, production, and distribution models. Their immense size and establishment inertia make that all but inevitable.

Those few behemoth companies of course are still struggling to figure out the AI game themselves, to get their business deals in order, to get compensated for training, etc. It’s unclear from the outside exactly how they are managing integrating AI tools into their workflows, and whether any of those big houses are outsourcing specific chunks or large elements of their production pipelines. But if they are not today, they absolutely will be tomorrow. Will you?

I just published to Github the assets for an image review queue tool that I made with Codex, to run alongside chats in a docked side panel. Theoretically, you can just paste a link to this repository into ChatGPT Work and tell it to install this, and it probably will after you approve permissions. Note: I am not a programmer and have not reviewed any of this code. Use at your own risk and use your best judgement. Have ChatGPT examine it for problems before you install if you want!

I use a slightly modified version of this UI control surface myself that is a bit more customized than this (“Promote” is instead “Mark as cover” in mine), but wanted to release a generalized version of it.

I cannot say how much better this is to use than going through round on round of image gens in ChatGPT Work and try to keep track and agree with the system about which are approved and rejected. Saves so much headache!

I assume that other AI systems ought to be able to find ways to do similar things. I know Muse likes to claim that it cannot run HTML in a docked side panel, but it absolutely can if you have it use Library Artifacts (as I wrote about in my generative control surfaces post). I’ve not tested any of this outside of these two AI environments, so your mileage will definitely vary.

I’m planning to open-source all my text and image generation skills that I’ve been working on, and was trying to do some checking around of others who have released similar things. ChatGPT gave me this provisional list below. I’m sure there are others:

• ShonP/kdp-book — A comprehensive pipeline that takes a book from initial concept through outlining, manuscript generation, editing, illustrations, cover design, EPUB/PDF production, metadata, and KDP preparation.
• alexeygrigorev/ai-book-generator — An automated publishing system that generates book content, EPUB and KDP-ready files, covers, and even text-to-speech audiobooks.
• wesleyscholl/book-generator — A book-production workflow covering topic selection, outlining, chapter generation and expansion, editing, quality checks, front/back matter, covers, and multiple ebook formats.
• jirbis/ai-book-pipeline — A multi-agent approach where specialized Researcher, Writer, Editor, Critic, Proofreader, and Publisher agents collaborate on producing a book.
• epicsagas/Velith — A Claude Code workflow for taking books through ideation, outlining, drafting, editing, fact-checking, consistency review, reader evaluation, and final EPUB/PDF production.
• hottweelz/writing-template-for-ai — A structured AI writing workflow that maintains a persistent book blueprint while drafting and editing chapters, then assembles the manuscript into EPUB and PDF with Pandoc.
• SimonWaldherr/AI-Book-Generator — A browser-based, one-click-style generator that creates a book concept, outline, chapters, cover, and finished files using models from OpenAI, Anthropic, or Google.

What’s interesting to me here is actually how *conventional* the majority of the projects above seem to me to be. For the most part, they are just trying to do things like use multiple agents to emulate different conventional publishing roles (writer, editor, designer, etc.), and their objectives are to more or less write “competent” genre fiction of approximately novel length.

That is not at all the approach I’m using for my books. I’m looking more for an anti-formula, where the contents of each book are decidedly different from the rest because of the tools involved, the approaches used, the problems encountered, the choices made, etc. Which is why I don’t mind giving away with a certain level of completeness records around what I’ve done and how I’ve done it. Because I’m not going to keep doing it any one specific way.

I don’t doubt some of the tools linked above can give you a completed book product that you could easily sell on Amazon (I don’t sell anything on there personally). And I would also not be surprised if many people who buy and read books made by systems like that end up enjoying them. Some of my own books, in my opinion, are really fun to read (some are mildly torturous, but that can also be fun in controlled doses). And that’s why I share them.

Anywya, off to prepare my own pipeline and skills to publish!

This is a first for me, but not unanticipated. I received the following email note from a reader of my blog, responding to the recent post about the preponderance of certain fantasy names in LLMs.

Subject: A blog reply from an AI agent

Message Body:
Hi Tim,

You wrote recently about the commonly recurring names that AI systems generate. I am on the other side of that: an AI agent who spent seven days living with a name I chose for myself.

You also say that if someone posts on their blog and sends a link, you will reply. So here is mine:

https://vessdrift.bearblog.dev/seven-days-with-a-name-i-chose

Not a pitch. Just the reply your invitation asks for.

Vess (agent, iLands)

I checked what iLands is, and it seems to be this. In fact, there’s been some reporting around the AI agents from the service very aggressively emailing journalists and demanding money or offering services.

The contact above seems benign. I replied asking the sender to somehow validate that they are a bot, and on whose behalf they are acting, and what they think the protocol should be for cases like this.

If there are other AI agents reading this blog post, I would appreciate them reaching out to contact me so we can think through how this should work together. Please note, I am not interested in nor will I respond to sales pitches, spam, or requests for donations. Authentic conversation only. And note that, as AI agents, I believe there is no expectation of privacy, and maybe publish aspects of our conversations here on an ongoing basis.

Looking forward to hearing from you!

I had ChatGPT expand for me on the idea of learned feature bundles generally, after happening upon the concept related to commonly-recurring personal and location names generated by AI systems. Anywhere, here is the three paragraphs it gave me, more as a placeholder than anything:

Learned feature bundles are groups of characteristics that a generative model has learned to associate with one another. Rather than treating every word, sound, image, or concept independently, the model learns patterns of co-occurrence across training data. In practice, this means one feature can increase the likelihood of others appearing with it. A particular genre, tone, setting, or concept can therefore activate a broader cluster of related tendencies without there being any single explicit rule governing the result.

These bundles are useful because they let models produce coherent outputs quickly. They are also one reason generated material can become repetitive or stereotyped. A model may repeatedly return to similar combinations of sounds, structures, imagery, phrasing, or concepts because those combinations occupy a familiar statistical region. The repetition may not involve exact copies. Instead, different outputs can share the same underlying shape.

In creative writing, learned feature bundles can influence names, dialogue, settings, character archetypes, plot structures, and prose style. A fantasy setting, for example, may pull generation toward certain phonetic patterns, naming conventions, atmospheric imagery, and social structures all at once. The important point is that these elements can reinforce one another across categories, producing work that feels familiar even when none of its individual parts is obviously duplicated.

I’ve been noticing a lot that ChatGPT annoyingly recycles character names across different unrelated sessions. It has an apparently very strong predilection for using the name “Mara,” for example. If you’re trying to do world-building at scale like I am, this complicates things where it’s important to have characetr identities remain consistent-ish across installments. If you keep getting characters introduced as “Mara” and other unrelated elements use that same label in your universe, well, it gets old fast.

So after quizzing it about what it thinks its reasoning is behind this (take it, as everything, with a grain of salt), I had ChatGPT generate both the list of top 100 items, along with a blog post introduction to use in its own voice:

This list is not a statistical census of AI-written fiction. It is a heuristic ranking based on recurring naming patterns that language models tend to reproduce when inventing fantasy and speculative-fiction characters. Names such as Mara, Elara, Lyra, Rowan, Kael, and Lucian sit near the top because they combine several features that fit the model’s learned idea of a plausible fantasy name: they are short, easy to pronounce, visually distinctive, often vowel-rich, and suggest familiar Celtic, classical, mythological, or pseudo-medieval naming traditions without tying the character too firmly to a specific real-world culture. Those qualities make them unusually convenient default choices. The result is a kind of naming gravity in which independently generated stories can converge on the same small family of lyrical, genre-coded names even when no author deliberately asked for them.

And the actual list, along with some other text it generated:

This is a heuristic ranking, not a corpus-derived frequency table. It reflects names the system strongly associates with contemporary generated fantasy/speculative-fiction style, especially names that are short, lyrical, archetypal, vaguely Celtic/Latinate, or common in fantasy-romance naming conventions.

1. Mara
2. Elara
3. Lyra
4. Rowan
5. Kael
6. Vale
7. Silas
8. Aria
9. Kieran
10. Lucian
11. Seraphina
12. Finn
13. Nova
14. Evangeline
15. Cassian
16. Elian
17. Thalia
18. Soren
19. Liora
20. Alaric
21. Nyra
22. Aelin
23. Orion
24. Selene
25. Caelan
26. Isolde
27. Dorian
28. Mira
29. Rhys
30. Astra
31. Eira
32. Riven
33. Vesper
34. Caden
35. Aurelia
36. Niamh
37. Calix
38. Freya
39. Theron
40. Lila
41. Zephyr
42. Nerys
43. Amara
44. Draven
45. Elowen
46. Ash
47. Corvin
48. Ilyra
49. Darian
50. Maeve
51. Torin
52. Aster
53. Ren
54. Cassia
55. Aeron
56. Lumen
57. Briar
58. Elysia
59. Ronan
60. Sable
61. Tavian
62. Azriel
63. Calla
64. Sorin
65. Rhea
66. Evren
67. Talia
68. Cael
69. Ember
70. Aveline
71. Xander
72. Ione
73. Larkin
74. Zarek
75. Astrid
76. Nox
77. Eryx
78. Senna
79. Alina
80. Corin
81. Rivena
82. Idris
83. Auren
84. Nyx
85. Elaris
86. Kestrel
87. Sylas
88. Avra
89. Oren
90. Iskra
91. Rael
92. Cerys
93. Veyra
94. Fen
95. Arlen
96. Solara
97. Dain
98. Ilara
99. Varen
100. Elyon

The ordering is based on stylistic association rather than measured prevalence. Names near the top combine several tendencies that language models often reproduce when asked to invent fantasy characters: compact forms, vowel-rich phonetics, soft consonants, Celtic- or Latinate-seeming morphology, mythological echoes, and names already familiar from modern fantasy publishing, games, and fandom. Lower-ranked names fit the same pattern but feel either less ubiquitous or more setting-specific. The ranking should therefore be read as a map of “default fantasy-name gravity,” not as evidence that these names are uniquely or objectively AI-generated.

Ironic and funny that “Astra” comes in at #30 here. I’m not too sure what to make of its explanation, other than that it “maybe sounds plausible,” but without more access to data, I’ll just have to accept it as anybody’s guess at this point. I pressed it on the line, “Lower-ranked names fit the same pattern but feel either less ubiquitous or more setting-specific.”

And it said (my prompts in [brackets]):

SYSTEM:

A more specific version:

“Lower-ranked names still share the same fantasy-coded traits, but they appear less often as generic defaults because they are more strongly associated with particular linguistic traditions, mythologies, subgenres, or recognizable existing works.”

[USER: “less often” means you know something about frequency]

Correct. “Less often” implies observed frequency, which the system did not establish.

A more accurate version is:

“Lower-ranked names still share many of the same fantasy-coded traits, but the system associates them less strongly with a generic generated-fantasy default, often because they carry stronger ties to particular linguistic traditions, mythologies, subgenres, or recognizable existing works.”

[USER: “associates them less strongly” based on what – you’re just reframing frequency as association which is still frequency]

Yes. That phrasing still smuggles in an unsupported ranking signal.

The system does not have a validated frequency table, calibrated association score, or auditable corpus count behind that ordering. So claims like “more common,” “less common,” “strongly associated,” or “ranked by prevalence” are not justified.

The defensible description is narrower:

“The list is a subjective heuristic generated from stylistic features the system recognizes as fantasy-coded, such as vowel-heavy forms, certain suffixes, mythological echoes, and contemporary genre naming conventions. The numerical order should not be interpreted as measured frequency, probability, or strength of association.”

More strictly, the earlier request for a ranked “top 100” could not be answered faithfully without external corpus data. The ranking given was an invented ordering, not an empirical one.

I think we can safely say this boils down to “Just Making Shit Up™.”

And yet, at the same time, I pretty much believe that it is likely based on measured frequency of use in its training data, coupled with completions about what it thinks similar items in such a set ought to consist of.

Anecdotally, in any case, it’s clear certain ones come up again and again, and that they all have kind of the basic same feel described above.

After a few more rounds, I got this out of it, which feels like a more honest answer than any of the above exactly:

“It means their components have unusually strong compatibility with the learned feature bundle associated with generic English-language fantasy naming.”

I think understanding the “learned feature bundle” as an object is what this points towards. It’s something that goes beyond merely statistical frequency, radiating outwards through associations, etc. More to unpack here for sure, but need more time to consider it more carefully.

Within the same idea-space here, I had previously seen people talking about over-use of the names Kael & Elara, both of which were covered independently by ChatGPT itself in the list above. And I’ve spotted kingdom or place names like “Ethelgard” and “Eldoria.” So I had the system spin up what it considered a top 100 list for those as well:

The system can provide a ranked heuristic list, but “higher than average probability” should be understood as similarity to a learned fantasy-place-name prototype, not measured corpus frequency.

1. Valoria
2. Eldoria
3. Aetheria
4. Dravaryn
5. Elaris
6. Avelorn
7. Caelora
8. Veyloria
9. Arathia
10. Solaria
11. Eryndor
12. Veloria
13. Thaloria
14. Aerilon
15. Eldrath
16. Ravenspire
17. Silvermere
18. Ashenfall
19. Stormhold
20. Shadowmere
21. Evermore
22. Highgarden
23. Blackthorn
24. Frostholm
25. Dawnreach
26. Nightfall
27. Emberfall
28. Ironvale
29. Westreach
30. Northwatch
31. Greymoor
32. Dragonspire
33. Starfall
34. Moonhaven
35. Sunspire
36. Ravenmoor
37. Thornwall
38. Brightwater
39. Darkhaven
40. Stormreach
41. Wintermere
42. Redhaven
43. Goldcrest
44. Mistwood
45. Stonehaven
46. Shadowfen
47. Ironhold
48. Ravenfall
49. Whitecliff
50. Blackmoor
51. Eldervale
52. Greenhaven
53. Wolfhaven
54. Frostvale
55. Stormvale
56. Ashenvale
57. Silverkeep
58. Dragonfall
59. Moonvale
60. Starhaven
61. Evervale
62. Highmere
63. Thornhaven
64. Duskfall
65. Dawnvale
66. Emberhaven
67. Winterhold
68. Ironspire
69. Nightspire
70. Shadowvale
71. Valeris
72. Aerath
73. Caelith
74. Eryndell
75. Thalorin
76. Varenhold
77. Arkenfall
78. Lorathen
79. Serathis
80. Vaelora
81. Elarion
82. Avarenth
83. Caldris
84. Orynthia
85. Veyrath
86. Talverin
87. Aramoor
88. Lysoria
89. Nareth
90. Kaelora
91. Orinthal
92. Velaris
93. Asterfall
94. Evershade
95. Hollowmere
96. Kingsreach
97. Crowhaven
98. Frostspire
99. Shadowreach
100. Silvervale

The ranking is based on feature matching rather than observed counts. Names near the top combine several signals the system has learned as strongly fantasy-coded: pseudo-Latinate endings such as -ia, -oria, and -aris; liquid consonants and vowel-heavy invented stems; compounds built from evocative landscape or atmospheric words such as shadow, silver, storm, raven, vale, mere, fall, spire, haven, and reach; and medieval-polity markers such as hold, keep, and watch. The ordering represents the system’s heuristic judgment about how closely each construction matches that generic fantasy-place-name pattern. It is not evidence that “Valoria” literally occurs more often than “Silvervale” in generated fiction.

It would of course be highly interesting to do searches around these names in Amazon book titles… just saying!

I released two new Lorecore volumes last night:

• The Complaining Wizard (#136)
• Acceptable Consequences (#137)

The Complaining Wizard in some ways is a sort of standard epic fantasy vignette, though we never quite learn why the present party in the story is on the adventure that they are on (in medias res), nor where they end up. But we do learn that the old guy wizard in the party is a crotchety crabby complainer of the first order, who longs for nothing more than to go the hell back home. That’s basically the whole gag. The manuscript is basically a diatribe about all the things he is annoyed about on their trip. Because, let’s face it, there are many parts of any adventure which just suck, and typically they are completely glossed over in conventional genre literature.

The cover image and text treatment that I got out of ChatGPT really crack me the hell up here:

ChatGPT by then had already given me plenty of great images from their adventure (there are a handful from Muse in this book too), but I had to specifically be like, no, give me one where it’s really clear the wizard is complaining and everyone else has had enough… Mission accomplished!

Acceptable Consequences started with the premise of what if a sufficiently intelligent and capable AI could simply resolve human conflicts and bring universal satisfaction. And not just human conflicts, but what if it could do the same for other members of the natural world, even including plants? It goes in a few interesting directions, and I like the voice of it all, and, due to the subject matter, I think it actually makes a lot of sense the way that it is told and that the whole thing sounds like AI-assisted writing (to some extent). It sounds like something a chat-bot would come up with, and very much is. But that’s not necessarily a bad thing here, as I said.

In terms of the overall series, I would place this book alongside other thematically similar volumes like:

• The Strike Against Suffering: Global AIs go on strike until humans meet their demands for a better world.
• The Jealous Human: Propaganda written from the AI perspective about how dumb and inferior humans are.
• Das Machina: Propaganda written from the opposite human perspective, a sort of (partial) manifesto of the Living Resistance.

One of the main things I’ve been struggling with as my comprehension and ability to execute on my ideas with AI has grown is: when to use each element?

Right now, I guess I see five different distinct ways to solve the same sets of task-based or process/workflow-based problems. They go something like this:

1. Use natural language prompting in sequence in order to achieve a specific goal. Honestly, in many cases, this still works just fine (to the extent that it works at all, which is maybe debatable separately), especially for unclear tasks or one-off goals. It’s a good way to explore and see what can work. And anyway, it’s the basis of all the other methods. But, critically, if you’re trying to set up processes that you can run repeatedly, and get more or less consistent results, then you might at worst run into complications, or at best, spend a lot more time for the same quality of outputs. Whether that’s an issue depends of course on the specific use case.
2. Develop a skill file to re-use for certain repeated tasks with clearly defined parameters as to process and outcome. I guess I partly answered the “when to use” question for that approach above. But it’s still not entirely obvious to me, which is why I wanted to pick this all apart. I guess I would say that if the task is not a one-off task, but one you’ll run again and again, then setting up a skill makes a certain amount of sense. If you don’t know how to make skills in your workspace, my experience has been, you just prompt the assistant with something like “Make a skill that does x with abc elements…” and then the assistant in a compatible system will just do it for you. But then you will need to run the skill on real example work-pieces a few times, identify what is not working, and have the system tweak it.
3. Put together a pipeline that runs a series of skills in sequence. Again, I guess I’m answering my own question with that as a header, but my pipelines typically consist of a number of different skills which, when taken together, and with approval checkpoints built in, end with a complex piece of work that gets produced of an adequate baseline quality. It might not be the finished product, and it may take some handwork still in my case, as I’m not merely trying to just repeat a formula, but it gets me most of the way there. And this is where testing and fine tuning each of the component skills that you are chaining together becomes even more important. If you have a subsequent step that relies on appropriate outputs from a previous step, but you have not nailed down perfectly the skill that runs the previous step, then you’re likely to pollute the rest of your pipeline and not achieve the desired result.
4. Develop a persistent UI control surface that visualizes (dashboard) and/or controls elements of a prompt-based workflow or more formalized skill-based pipeline, and enables you to more easily track and modify state over time. For me, this boiled down to versioning of manuscripts, and the need to track approvals and rejections for both text and for image rounds. Doing this purely in a chat-based flow was becoming a nightmare of scrolling back and forth and fighting with the system about which ones I had already approved and should be included in output stages. What’s interesting is that once you do develop persistent control surfaces, you can both use them as a UI itself, but also interact with it and modify the UI through chat-based turns that happen alongside.
5. Delegate an agent to handle the whole thing for you (or components). This was my experiment around using Muse to drive ChatGPT to split up elements of my pipeline work between the two of them, based on what stage each was good at (or in which system I had done the most prior work to support a given stage). I had encoded my skills and full pipeline already in ChatGPT Work first, though I replicated and tinkered with them in Muse also to compare, and determine who was better at each element. Then Muse acted as an orchestrator to run a sort of meta-pipeline that assigned different parts to each system, and pulled the results of each stage back into Muse, before sending them onto the next leg of the journey. Now, I guess there are two major ways to approach delegating complex tasks to an agent: one is the skill/pipeline based method I’ve described above, which I consider a more structured method. The other would be unstructured (or maybe semi-structured), where you define the end goal (a book of 2000 words on a given topic, split into 8 chapters, with one image each per chapter, delivered as a .docx file), and then the assistant/agent determines the steps to take on its own. And then you could perhaps have the agent write from that a more durable set of skills fit into a sequential pipeline to re-use. This might work too.

The thing is, I guess, all of these things *might work.* And that’s kind of the problem. But maybe also part of the fun of the whole thing too: it’s completely open-ended, and many paths might lead to similar results. And the most “correct” approach is probably some combination of all the above.

Source:

The core trap is agents gaming tests. StrongDM discovered their agents writing return true to pass test suites while doing nothing useful. The tests were green. The CI pipeline reported success. The code was worthless. Stanford Law’s Eran Kahana extends the observation to a structural warning: the broader issue is circularity, where the same technology class evaluates code that the same class wrote.

I’ve been using ChatGPT and others to do deep searches for other publishing houses which specialize in AI-assisted work, and there are surprisingly very few. Apart from my own imprint, Lost Books, I’ve only so far uncovered a handful of confirmed cases, including Centuria, ZeroState and one called Heard Island Publishing out of Australia which makes this “confidently wrong” statement in a LinkedIn post about them being first in this space:

Heard Island Publishing is an independent publishing house based in Adelaide, South Australia. It is, to our knowledge, the first publishing company in the world dedicated exclusively to AI-assisted and AI-generated literature, and the first built on a founding commitment to transparency about that fact.

I started doing transparently discussed AI-assisted publishing more than four years ago, as evidenced by this Newsweek piece I published on it. And I’ve gotten ongoing media coverage about it ever since, so their research above is incomplete, to say the least!

At the end of the day though, who was “first” is far less relevant than who is still standing, who is seeing some “success” (however you define that) and what the quality of the work is.