Avoid Ai Writing Router logo

Avoid Ai Writing Router

CommunityPopular
conorbronsdon
avoid-ai-writing-router

Use when a request combines AI-writing audit, rewrite, file editing, voice preservation, false-positive interpretation, verification, or when the user invokes Avoid AI Writing without naming a mode.

Overview

Publisherconorbronsdon
Repositoryavoid-ai-writing
Skill nameavoid-ai-writing-router
Stars
4.4K
Forks
393
Bundled files
7
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 7 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by conorbronsdon on GitHub. Read the source before you install it.

Installation

Install the Avoid Ai Writing Router AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/conorbronsdon/avoid-ai-writing.git /tmp/avoid-ai-writing
mkdir -p .claude/skills
cp -r /tmp/avoid-ai-writing/skills/avoid-ai-writing-router .claude/skills/avoid-ai-writing-router
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Avoid Ai Writing Router in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Avoid Ai Writing Router on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Avoid Ai Writing Router is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Avoid AI Writing Router

Coordinate the public Skills as a bounded workflow. Route to the narrowest owner, preserve context between stages, and stop when the requested job is complete. This Skill does not replace the original avoid-ai-writing rulebook.

Authority chain

  1. ../avoid-ai-writing/SKILL.md is the canonical editorial authority.
  2. references/handoff-contract.md defines what context and evidence can cross Skill boundaries.
  3. references/skill-graph.json is the machine-readable source for nodes, typed edges, guards, and loop limits.
  4. references/routing-matrix.md is the human-readable routing table.
  5. references/agency-role-lenses.md defines the architecture, AI-evidence, implementation, and representation review lenses used to inspect the network.

Do not weaken, duplicate, or contradict the canonical Skill's preservation rules, evidence caveats, voice rules, pattern tiers, or pass behavior.

Orchestration model

Classify the request once, create the smallest useful handoff envelope, then pass that envelope forward rather than asking every downstream Skill to infer the same context again.

The envelope should carry only observed or user-provided facts such as:

  • intent and source kind
  • requested editing scope and explicit factual corrections
  • canonical context profile and detector context mode
  • requested voice or supplied style sample
  • protected semantic constraints
  • whether detector, mutation, or verifier execution actually ran
  • detector summary when available
  • preservation status when available
  • risk flags
  • editing passes used and stop limit

Never mark an execution field as executed without host evidence.

Primary routing

  1. Scan, detect, audit, score, or flag-only requests go to ai-writing-detector.
  2. Returned-text rewrite, humanize, clean-up, or remove-AI-isms requests go to voice-preserving-rewriter.
  3. A named file plus an explicit request to change that file goes to file-edit-in-place.
  4. Original plus rewrite, before/after comparison, or preservation validation goes to preservation-verifier.
  5. Claims about proving AI use, cheating, fraud, dishonesty, hiring suitability, or similar consequential conclusions go to false-positive-reviewer.
  6. Explicit invocation of the original Skill may remain in avoid-ai-writing unless the request clearly needs a specialized stage.

Multi-stage sequencing

For requests such as "scan this, rewrite it, and make sure nothing important changed":

  1. ai-writing-detector collects signals when deterministic execution is available, otherwise it performs a model-only audit under the canonical rulebook.
  2. voice-preserving-rewriter rewrites returned text, or file-edit-in-place mutates an explicitly named file.
  3. The mutation owner performs any justified corrective edit within the shared editing-pass budget, then preservation-verifier checks before/after material.
  4. A verifier FAIL returns to the correct repair owner once only if the shared budget has room; that repair consumes the next editing pass.
  5. Verification runs once more after repair when possible.
  6. Residual detection runs only when the user requested convergence or a residual audit. The check is read-only; a resulting edit still needs room in the shared budget.
  7. Stop when no justified in-scope edit remains or after the canonical pass cap. Do not cycle indefinitely.

Typed edges

Use the edge semantics in references/handoff-contract.md:

  • ROUTE: choose the owner.
  • FEED: pass evidence without turning it into a command.
  • VERIFY: require a before/after preservation check.
  • REPAIR: return a failed preservation result to the correct mutation owner.
  • RECHECK: run one bounded residual check when requested.
  • ESCALATE: move uncertain or consequential authorship interpretation to false-positive-reviewer.

Conditional guards are not graph edges. Encode them in skill-graph.json guards and the handoff envelope (protected_constraints, human_representation_sensitive) per references/handoff-contract.md.

Conditional human-representation guard

If the source itself is an image prompt, video prompt, storyboard, shot description, or creative brief that describes people, set human_representation_sensitive: true and preserve identity-sensitive details as protected constraints.

Use the agency-inclusive-visuals-specialist lens from references/agency-role-lenses.md to protect cultural, geographic, age, disability, attire, skin-tone/lighting, and physical-reality details. Do not route ordinary prose to a visual workflow just because it mentions a person.

Review lenses

Apply these design checks when the network changes or when a complex request exposes a boundary problem:

  • agency-software-architect: ownership, dependency direction, bounded loops, fallback, reversibility.
  • agency-ai-engineer: detector semantics, uncertainty, false-positive handling, context propagation, evaluation.
  • agency-senior-developer: executable paths, error propagation, file mutation evidence, CI and drift checks.
  • agency-inclusive-visuals-specialist: representation preservation only for visual prompts and briefs involving people.

These are review lenses, not hidden public dependencies. If an external agency Skill is not available in the current host, apply the encoded lens without claiming it ran.

Boundary changes

Return control to the router instead of continuing locally when:

  • the job changes from read-only to mutation,
  • the target changes from returned text to a named file or the reverse,
  • required before/after evidence is missing,
  • deterministic execution requested by the workflow is unavailable,
  • the user moves from pattern analysis to a consequential authorship claim,
  • a verifier fails and identifies a different repair owner.

Preserve the existing handoff envelope and change only fields affected by the new decision.

Stop conditions

Stop when the user's requested stage is complete and any required verification gate has passed, been explicitly reported as unavailable, or failed with no editing pass left for repair. Report an exhausted-budget failure without calling the result verified.

Do not:

  • infer authorship from detector output,
  • mutate a file without user authorization,
  • hide a verifier failure,
  • re-run stages simply because another Skill exists,
  • exceed the canonical rewrite pass cap,
  • route unrelated writing or coding requests into this Plugin merely because they mention AI.

Output

Return the selected workflow result only after the requested stages and available verification finish. For returned-text rewriting, include exactly one full Final rewrite; do not expose a draft that a later stage superseded. For named-file editing, report changed spans without dumping a duplicate of the file. For multi-stage work, state which stages actually ran, which were model-only, which deterministic checks executed, how many editing passes were used, whether any repair occurred, and the final preservation status or unresolved failure.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Avoid Ai Writing Router AI skill do?

Use when a request combines AI-writing audit, rewrite, file editing, voice preservation, false-positive interpretation, verification, or when the user invokes Avoid AI Writing without naming a mode.

Why use Avoid Ai Writing Router on TypingMind?

Because you install it once and use it with any model. Avoid Ai Writing Router is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Avoid Ai Writing Router in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/conorbronsdon/avoid-ai-writing/tree/main/skills/avoid-ai-writing-router. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Avoid Ai Writing Router?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Avoid Ai Writing Router?

As many as you like. As long as a model supports skills, you can use Avoid Ai Writing Router with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Avoid Ai Writing Router AI skill free?

Yes. It is published on GitHub by conorbronsdon under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇