Prosetheus

Prose + Prometheus — bringing the fire of creative AI to writers.

A CLI tool for creative writing with AI agents. Its core mission: eliminate AI-sounding prose. Regardless of style guides, LLMs slip into the same overused words, structures, and rhythms. Prosetheus attacks this with pattern matching, statistical analysis, and LLM self-critique — backed by a living pattern database that evolves through use and can be shared across the community.

Beyond anti-slop, it supports long-form fiction with multi-agent collaboration, structured pipelines, and persistent memory.

Installation

Prerequisites

1. Node.js 20+ — check with node --version. Install from nodejs.org (LTS) if needed.
2. Claude Code CLI — Prosetheus uses Claude as its AI engine. You need a Claude Pro or Team subscription and the Claude Code CLI installed.

Install via npm

npm install -g prosetheus

That's it. You now have the prose command. Verify it works:

prose --version

Install from source

If you want to develop or contribute:

git clone https://github.com/OtterLodge/Prosetheus.git
cd Prosetheus
npm install
npm run build
npm link

After code updates: If you pull new code or make changes, run npm run build again to recompile. You don't need to re-run npm link.

Getting Started

1. Create a new project

Navigate to an empty folder where you want your novel to live, then:

prose init "My Novel" --genre fantasy

This creates all the folders and config files you need. You only do this once per project.

2. Start writing

prose chat

This opens an interactive chat session with the default creative writing agent. Type your requests ("Write the opening scene", "Help me outline chapter 2", etc.) and the agent will respond using Claude — with anti-slop detection built in.

To use a specialized agent:

prose chat --agent drafter    # Prose specialist (strict anti-slop)
prose chat --agent editor     # Catches everything, maximum strictness
prose chat --agent outliner   # Story structure specialist
prose chat --agent analyzer   # Pattern mining specialist

Type /quit or press Ctrl+C to end the session.

3. Open the Writing Room

The Writing Room is a multi-agent discussion system where Shelly (the showrunner) moderates a collaborative session between agents.

# Basic discussion
prose room "Build tension in chapter 5" --protocol draft-review

# Brainstorm with the team
prose room "Develop the antagonist" --protocol brainstorm

# Pick specific agents
prose room "Polish the diner scene" --participants drafter,editor,analyzer

By default you choose the participants yourself with --participants. With --plan, Shelly analyzes the task and picks the right team automatically — including lens agents and character agents from your data/characters/ sheets:

# Shelly picks the team
prose room "Review the kitchen argument between Steve and Ann" --plan

# Force a specific interaction mode
prose room "Fact check the 1960s details in chapter 3" --plan --mode independent-review

Shelly can choose between table-read (multi-round discussion) and independent-review (parallel single-pass reviews), or you can override with --mode.

4. Manage your anti-slop patterns

# See all patterns the system checks for
prose patterns list

# See just the banned words
prose patterns list --level granular

# See just the phrase patterns
prose patterns list --level micro

# Export your patterns to share with others
prose patterns export my-patterns.md

# Import someone else's pattern collection
prose patterns import their-patterns.md

How Anti-Slop Works

This is the core feature — the whole reason Prosetheus exists.

What it catches

Banned words (granular) — individual words that scream "AI wrote this":

delve, tapestry, nestled, beacon, testament, myriad, palpable, visceral, ethereal, cacophony, gossamer, luminous...

24 words ship by default. You can add your own.

Cliché phrases (micro) — overused phrases and sentence structures:

"couldn't help but", "a shiver ran down", "[emotion] washed over", "a testament to", "It was as if", "Little did they know", "in that moment"...

20 phrases ship by default. Each comes with a "bad" example and a "good" replacement.

Structural patterns (macro) — repetitive paragraph and prose patterns:

Every paragraph follows setup-detail-reflection. Every scene ends with a meaningful realization. All paragraphs are the same length. Dialogue always bracketed by emotional narration.

6 macro patterns ship by default. These are detected by statistical analysis and LLM review, not regex.

How it detects them

1. Pattern matching — fast regex scan against the pattern database. Catches banned words and phrases instantly.
2. Statistical analysis — measures your prose for healthy variation:
   • Are your sentences different lengths, or all the same? (sentence length CV)
   • Do you start sentences with different words? (opener diversity)
   • Too many adverbs? (adverb density)
   • Too much passive voice? (passive voice ratio)
   • Are your paragraphs varied in length? (paragraph length CV)
   • Do you repeat the same 3-word phrases? (repeated phrase density)
3. LLM self-critique (coming in Phase 3) — the agent re-reads its own output to catch subtle patterns that regex can't.

How strict each agent is

| Agent | Strictness | What it does | |-------|------------|--------------| | outliner | Low | Aware of patterns, doesn't actively scan | | default | Medium | Avoids known patterns, scans when you ask | | drafter | High | Actively avoids patterns while writing, auto-scans after | | editor | Maximum | Catches everything, runs all detection methods, rewrites violations | | analyzer | Maximum | Reads text and discovers NEW patterns to add to the database |

The pattern database

Patterns come from three places, merged together at runtime:

1. Default patterns — ship with Prosetheus (50 patterns)
2. Your global patterns (~/.prosetheus/patterns/custom.json) — your personal additions, shared across all projects
3. Project patterns (.prosetheus/patterns/project.json) — patterns specific to one project

Project patterns override global, which override defaults. So if you want to un-ban a word for a specific project, you can.

Self-learning

When you or an agent flags something as AI-sounding, Prosetheus tracks it. If the same pattern gets flagged 3+ times across 2+ sessions within 30 days, it automatically gets promoted into your project's pattern database. The system gets smarter the more you use it.

Project Structure

After prose init, your project folder looks like this:

my-novel/
  .prosetheus/                  # Prosetheus config (don't delete this)
    project.md                  # Project settings (name, genre, agents)
    pipelines/                  # Multi-stage workflows
      outline-to-draft.md
    patterns/                   # Project-specific anti-slop patterns
    reports/                    # Scan reports
  CLAUDE.md                     # Instructions that all agents follow
  manuscript/                   # Your chapter files go here
    chapter-01.md
    chapter-02.md
  data/
    characters/                 # Character sheets (used by character agents)
    plot/                       # Plot arcs
    timeline/                   # Timeline events
    world/                      # Worldbuilding notes
    style/
      style-guide.md            # Your style guide
      preferences.md            # Project-level author preferences
    research/                   # Research notes
  outlines/                     # Chapter outlines

You can edit any of these files directly — they're all markdown.

Agents

Prosetheus has two categories of agents: role agents that perform tasks, and lens agents that check specific quality dimensions.

Role Agents

Role agents are AI personalities defined as markdown files. Each one has different capabilities and anti-slop strictness. They live in ~/.prosetheus/agents/.

| Agent | What it's for | |-------|---------------| | default | General-purpose creative assistant. Can do a bit of everything. | | outliner | Story structure, beat sheets, plot arcs. Focuses on narrative scaffolding. | | drafter | Writes prose. High anti-slop strictness — scans everything it writes. | | editor | Revision and consistency checking. Maximum strictness. Catches everything. | | analyzer | Reads text and discovers repeating patterns. Doesn't write prose — just analyzes it. | | shelly | The showrunner. Moderates Writing Room sessions, plans agent composition. |

Lens Agents

Lens agents are specialist reviewers focused on a single quality dimension. They live in ~/.prosetheus/lenses/.

| Lens | What it checks | Needs project data? | |------|----------------|---------------------| | dialogue | Character voice, speech patterns, dialogue naturalness | Yes — reads character sheets | | factual-accuracy | Historical accuracy, physical plausibility, anachronisms | No — uses web search | | physical-continuity | Spatial consistency within scenes (positions, objects, blocking) | No | | plot-continuity | Story-level consistency across chapters (timeline, character knowledge) | Yes — reads plot/timeline data | | story-style | Tone, pacing, style guide adherence | Yes — reads style guide | | user-preferences | Author's stated narrative tastes and preferences | Yes — reads preferences files |

Character Agents

Character agents are created dynamically from your character sheets. When you use --plan with the Writing Room, Shelly can spawn a character agent for any character that has a sheet in data/characters/. A character agent:

• Knows the character's voice, background, and motivations
• Flags dialogue that doesn't match their speech patterns
• Tracks their physical and emotional state through a scene
• In table-read mode, can react in-character to other characters' lines

Customizing agents

To customize any agent, edit its CLAUDE.md file:

• Role agents: ~/.prosetheus/agents/<name>/CLAUDE.md
• Lens agents: ~/.prosetheus/lenses/<name>/CLAUDE.md

The YAML frontmatter controls capabilities and strictness; the markdown body is its personality and rules.

Author Preferences

The user-preferences lens reads from two files:

1. Global (~/.prosetheus/preferences.md) — your general tastes across all projects (e.g., "I love morally grey characters", "I hate love triangles")
2. Per-project (data/style/preferences.md) — preferences specific to one project (e.g., "this book should feel like a slow burn")

Project preferences override global when they conflict. Both are created as templates during prose init.

Tools Available to Agents

When agents are running, they have access to these tools automatically:

Prose scanning — prose_scan, prose_stats, pattern_list, pattern_add, pattern_flag, slop_report

Manuscript — manuscript_read, manuscript_write, manuscript_list, manuscript_word_count

Project — project_status

Plus all of Claude Code's built-in tools (reading files, writing files, searching, etc.).

Command Reference

| Command | What it does | |---------|-------------| | prose init "Name" --genre fantasy | Create a new project in the current folder | | prose chat | Chat with the default agent | | prose chat --agent drafter | Chat with a specific agent | | prose chat --no-resume | Start a fresh session (don't continue previous) | | prose room "topic" | Open a Writing Room discussion | | prose room "topic" --plan | Shelly selects agents and interaction mode | | prose room "topic" --plan --mode independent-review | Force independent review mode | | prose room "topic" --participants drafter,dialogue | Pick specific agents/lenses | | prose room "topic" --protocol brainstorm | Use brainstorm protocol | | prose patterns list | List all active anti-slop patterns | | prose patterns list --level granular | List only banned words | | prose patterns list --level micro | List only phrase patterns | | prose patterns list --severity high | List only high-severity patterns | | prose patterns import file.md | Import patterns from a markdown file | | prose patterns export file.md | Export all patterns to a shareable markdown file |

For Developers

# Type-check without building
npm run typecheck

# Run tests
npm test

# Run tests in watch mode (re-runs on file changes)
npm run test:watch

# Build (compiles TypeScript to JavaScript)
npm run build

Build Phases

• Phase 1: Foundation + Anti-Slop Core
• Phase 2: Creative data tools (character, plot, timeline, worldbuilding) + pipeline execution + Writing Room + dynamic agent system
• Phase 3: Memory system (tiered memory, knowledge graph) + self-learning loop
• Phase 4: Research tools, chat enhancements, pattern sharing, reporting review workflow