HowlWriter ハウルライター // 2026

Most AI writing utilities operate as thin wrappers: prompt in, prose out, no verification, no memory of what changed or why, and no mechanism for writing to be rigorously challenged before being declared finished. When models write or edit unconstrained, they produce recognizable synthetic hallmarks: canned transitions, repetitive tricolons, excessive polish that sands away the author's voice, and subtle semantic drift that alters technical facts or drops crucial qualifications.

HowlWriter is not built to "beat AI detectors." AI detectors are unreliable heuristics and are never treated as a measurement in this codebase. Instead, HowlWriter is engineered to produce writing that reads as authentically human and preserves the voice and exact meaning of the author.

HowlWriter is organized into cleanly separated subsystems. Downstream packages depend on a real, span-addressable domain model:

src/howlwriter/
├── domain/       Document, Paragraph, Sentence, Claim, Source, Evidence,
│                 ProvenanceGraph, VoiceProfile, WritingReport
├── config/       Layered config: defaults → mode → user → project → request
├── linting/      Deterministic style-rule engine (10 builtin rule families)
├── humanize/     AI-habit detector + opt-in SafeRewriter + ModelHumanizerRewriter
├── editing/      PassthroughEditor (whitespace/headings) + model Editor Protocol
├── redpen/       RedPenEngine (pure critique and argumentation challenge)
├── facts/        HeuristicClaimExtractor + ClaimVerifier Protocol
├── research/     Researcher Protocol (search & source discovery seam)
├── citations/    APA7Formatter with missing-metadata warnings (MLA/Chicago reserved)
├── voice/        CorpusStatsLearner (deterministic standard library statistics)
├── review/       MeaningPreservationReviewer (heuristic diff) + ModelMeaningReviewer
├── integration/  HowlPlaneWritingBridge + WritingRole protocols + ModelRoleNotConfiguredError
├── pipeline/     run_howl_pipeline (end-to-end orchestration)
└── cli/          Command line interface (13 capability subcommands)

Span-Addressable Document Model: Document.parse() breaks prose into structured Paragraph and Sentence spans. This allows Red Pen critique, style linting, and claim extraction to pinpoint "paragraph 3, sentence 2" instead of opaque character offsets.

HowlWriter does not send every problem to an LLM. Purely mechanical tasks belong to deterministic algorithms, while semantic transformations run under strict control:

Large language models default to predictable linguistic patterns. HowlWriter identifies and reduces these generic habits while protecting intentional stylistic choices:

Findings-First Architecture: By default, HowlWriter is findings-only. It reports locations and explanations without silently modifying text. Safe literal substitutions (e.g. replacing delve with explore) require the explicit --apply flag or a configured HUMANIZER model pass.

Generic writing assistants summarize style with simplistic adjectives like "professional" or "conversational." This strips away the idiosyncratic voice of the author. HowlWriter builds a structured VoiceProfile grounded in statistical reality:

Honest Metric Policy: Calculating a defensible "voice match percentage" requires a validated comparison distance model. Because approximating this without validation produces misleading results, HowlWriter leaves voice_match as None and omits the line from reports rather than inventing an arbitrary number.

A major hazard in AI editing is semantic drift: a rewrite sounds smoother, but subtly alters claims, removes necessary qualifications, drops technical constraints, or changes statistical numbers.

The Red Pen Engine: Pure criticism without rewriting. The Red Pen flags logical leaps, unsupported assertions, and passive evasions, providing clear editorial commentary while leaving the pen in the author's hand.

HowlWriter maintains a strict separation of concerns with HowlPlane:

• HowlWriter owns: Writing semantics, domain roles (HUMANIZER, FINAL_REVIEWER, RED_PEN, WRITER), prompt contracts, deterministic linting, and meaning-preservation rules.
• HowlPlane owns: Model execution, provider resolution (Claude, Codex, local Ollama), routing, timeouts, independent reviewer enforcement, and evidence ledger persistence.

                              ┌────────────────────────┐
                              │  HOWLWRITER PIPELINE   │
                              └───────────┬────────────┘
                                          │
                                   WritingRole Request
                                   (Domain: writing)
                                          │
                                          ▼
                              ┌────────────────────────┐
                              │   HOWLPLANE CONTROL    │
                              │ RoleDispatcher Engine  │
                              └─────┬────────────┬─────┘
                                    │            │
            Execute HUMANIZER Role  │            │ Enforce avoid_provider
            (e.g., Provider: Claude)│            │ (e.g., Provider: Codex)
                                    ▼            ▼
                             ┌────────────┐┌────────────┐
                             │  MODEL A   ││  MODEL B   │
                             │ Humanize   ││ Review     │
                             └─────┬──────┘└─────┬──────┘
                                   │             │
                                   └──────┬──────┘
                                          │
                                   Durable Evidence
                                 IndependenceStatus
                                          │
                                          ▼
                              ┌────────────────────────┐
                              │   HOWLWRITER REPORT    │
                              │ STATUS: READY / REVIEW │
                              └────────────────────────┘

Observable Reviewer Independence: When multiple providers are configured, HowlPlane ensures the model evaluating meaning differs from the model that performed the rewrite. The result is transparently recorded as INDEPENDENT, SAME_PROVIDER, NOT_REVIEWED, or UNAVAILABLE.

Appending disconnected URLs at the end of an article fails to establish actual truth. HowlWriter features a queryable in-memory ProvenanceGraph linking claims, sources, and evidence in both directions:

Every HowlWriter capability is accessible via a standalone CLI subcommand:

# 1. Deterministic style & AI habit linting
howlwriter lint draft.md

# 2. Humanization findings (and opt-in safe rewrite)
howlwriter humanize draft.md --deterministic --apply

# 3. Pure Red Pen critique without modifying prose
howlwriter red-pen draft.md

# 4. Extract factual claims (all claims start UNVERIFIABLE)
howlwriter fact-check draft.md

# 5. Generate formatted APA 7 citations from source metadata
howlwriter cite apa7 sources.json --form parenthetical
howlwriter references apa7 sources.json

# 6. Learn author voice profile from a corpus of real writing
howlwriter voice learn post1.md post2.md --author "Jane Doe"

# 7. Compare meaning preservation between original and revised drafts
howlwriter finalize original.md revised.md

# 8. Execute the complete end-to-end pipeline
howlwriter howl draft.md

Real Execution Report Output

HOWLWRITER REPORT

Mode:                  TECHNICAL
Humanizer:             claude_code
Meaning Reviewer:      codex
Reviewer Independence: INDEPENDENT

Deterministic Lint:
  Before:              4 findings
  After:               0 findings

AI-style warnings           0
Banned words                0
Meaning Preservation:
  Deterministic:       PASS
  Semantic Review:     PASS

Changes:
- Restructured passive constructions in paragraph 2
- Replaced canned transition "At its core" with concrete technical context
- Preserved author's intentional sentence fragment in paragraph 4

STATUS: READY

HowlWriter is under active development and dogfooding. We represent current capabilities transparently:

HowlWriter is part of the unified Howl software ecosystem: