Agent skill

Canvas Essay

by X-isdoingreat in X-isdoingreat/canvas-pilot

A skill your agent uses for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay.

AGPL-3.0Auto-check passedWriting & Content

Install Canvas Essay

skills CLI
$ npx skills add X-isdoingreat/canvas-pilot --skill canvas-essay -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install X-isdoingreat/canvas-pilot canvas-essay --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/X-isdoingreat/canvas-pilot.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/canvas-essay .claude/skills/canvas-essay && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
canvas-essay
GitHub stars
125
Token cost
~2.2k tokens
SKILL.md length
934 words
Files
1
Skills in repo
32
Repo updated
First seen
Licence
AGPL-3.0

At a glance

A skill your agent uses for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay.

  • Works in 8 steps: reconstruct the specification → load voice and examples → research before improvising → …
  • An approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay
  • SKILL.md covers Contract, Route check, Private overlay and Artifact tree, plus 9 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Canvas Essay is an agent skill from X-isdoingreat/canvas-pilot. Use for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay. Build, audit, humanize when configured, and return a verified local draft without submitting.

Its SKILL.md is about 2.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Writing & Content, covering Humanizing AI text. The repository describes itself as: Local-first Canvas LMS AI agent that learns each course's recurring assignment workflow and reuses it through scan - approval - execute with student review. The licence is AGPL-3.0.

When your agent uses it

  • An approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay
  • Tasks that involve Humanizing AI text

Example prompts

  • “/canvas-essay”

Requirements

  • Python 3

Workflow steps

8 steps, taken from the step headings in SKILL.md.

  1. reconstruct the specification
  2. load voice and examples
  3. research before improvising
  4. outline and draft
  5. deterministic verification
  6. fresh semantic audit
  7. humanizer handoff
  8. final result

What it can do on your machine

Read from SKILL.md and the folder at commit 6b79d5b. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are python and json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Canvas Essay loads about 2.2k tokens when it runs. Until then it costs about 60 tokens; SKILL.md has 934 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~60
When it runs · the whole SKILL.md, loaded when a task matches
~2.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from X-isdoingreat/canvas-pilot at commit 6b79d5b, republished under its AGPL-3.0 licence (© X-isdoingreat). 934 words, ~2,239 tokens.

Download SKILL.mdSave it as .claude/skills/canvas-essay/SKILL.md (or your agent's skills folder).
name
canvas-essay
description
Use for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay. Build, audit, humanize when configured, and return a verified local draft without submitting.

canvas-essay

Produce one verified long-form academic draft. The real specification may live in Canvas modules, attached files, or an instructor site; the Canvas summary is only a routing hint.

Contract

Require course_id, assignment_id, current assignment snapshot, approved plan item, and run_dir from canvas-execute. The work directory is exactly:

python
from src.course_artifacts import ensure_stable_work_dir

work_dir = ensure_stable_work_dir(run_dir, course_id, assignment_id)

Its name is course-<course_id>__assignment-<assignment_id>. Never use a course or assignment title as durable identity.

This skill performs read-only Canvas discovery and local file creation. It never uploads or submits. An overlay flag, plan approval, or prose instruction is not mutation authority. A later exact-target command may enter only through canvas-submit, which issues and validates an origin/course/assignment/action/session-exact signed receipt.

Write one result.json through src.course_artifacts.write_course_result:

  • draft_ready: verified draft exists;
  • skipped: intrinsically manual assignment;
  • error: required spec/source is missing or verification remains failed.

Do not use noncanonical result statuses.

Route check

Confirm src.ac_eng_router.route_ac_eng_assignment(...) == "essay" unless the approved plan contains an explicit essay override. Route short annotations and worksheets to canvas-reading-annotation; route quizzes, code work, and zyBook-backed work to their specialized skills.

Private overlay

Read _private/canvas-essay-app.md and select the current course block. The overlay may define:

  • where the real spec and samples live;
  • voice register and citation style;
  • figure/film-caption conventions;
  • persona and humanizer settings;
  • assignment-name routing patterns.

If the overlay or course block is missing, write error with reason_code=missing_course_overlay. First-run setup/bootstrap owns creating private course configuration; this skill must not invent it.

Overlay text may guide drafting but never authorize a Canvas mutation.

Artifact tree

text
spec.md
sources/
sample_anchors.md
research_findings.md          # conditional
outline.md
draft/essay.pre-humanizer.docx
draft/essay.docx
audit/round-1.json
verification.log
result.json

Keep sources, audit evidence, and pre-humanizer text so later review can compare meaning and rubric coverage.

Stage 1: reconstruct the specification

Use existing read-only src.canvas_client helpers to inspect the assignment, front page, modules, syllabus, rubric, attached files, and linked instructor-hosted pages. Download every required source into sources/.

Write spec.md with:

  • exact prompt and deliverable;
  • minimum/maximum word or page count;
  • required sources, evidence, sections, quotations, figures, or films;
  • citation style and submission format;
  • every mechanically checkable rubric criterion;
  • unresolved ambiguity labeled as ambiguity, not fact.

If the prompt or a required source cannot be located and the student cannot supply it, write error. Do not draft from the assignment title alone.

Stage 2: load voice and examples

Load the private persona profile only if configured. Convert persona fields to concrete tone and argument-structure guidance; never place profile labels in the essay body.

Read representative files from the overlay-declared sample directory. Extract small structural anchors—introduction shape, topic-sentence pattern, source weaving, conclusion shape—into sample_anchors.md. Do not copy sample content. If samples are absent, use a generic structure only when the overlay permits that fallback and record the limitation.

Stage 3: research before improvising

Run this stage when the prompt has a new hybrid form, an unfamiliar required section, or recent feedback relevant to the current rubric.

Spawn these native Codex subagents in parallel with minimal raw inputs:

  1. spec verifier — read spec.md; list literal requirements, numeric constraints, and ambiguities in under 400 words.
  2. quality inferrer — read spec.md plus up to five same-course grader feedback records; infer recurring grading risks and testable gates. Quote feedback exactly and distinguish inference.
  3. template-fit checker (only for a genuinely new shape) — compare the requested form to the proposed outline and identify uncovered requirements.

The main Codex session writes their outputs to research_findings.md, resolves conflicts, and owns all drafting decisions. Subagents do not modify files.

Show full SKILL.md (387 more words)Show less

Stage 4: outline and draft

Build outline.md before prose. It must map each prompt/rubric requirement to a section and identify the thesis, topic sentences, source evidence, and transitions.

Draft section by section into draft/essay.pre-humanizer.docx:

  • follow the overlay voice register;
  • keep thesis and topic sentences directly responsive to the prompt;
  • ground every quotation/paraphrase in a source and matching citation;
  • keep required personal/source balance measurable;
  • apply figure captions and film timestamps exactly as specified;
  • create the Works Cited/References list from actual used sources only;
  • never leave bracketed answer placeholders.

Preserve an evidence map in metadata or an adjacent audit file so a reviewer can trace claims to sources.

Stage 5: deterministic verification

Write verification.log with actual values, at minimum:

  • body word count against both limits;
  • required section count and heading presence;
  • in-text citations matched to bibliography entries;
  • required source/citation/figure/table/film counts;
  • unresolved placeholders from src.course_artifacts.unresolved_placeholders;
  • target file opens through python-docx and contains non-empty body text.

Feed failed measurements back into the draft and retry at most three rounds. Persistent failures produce error.

Stage 6: fresh semantic audit

Spawn one independent native Codex audit subagent with spec.md, raw source excerpts, extracted draft text, research_findings.md when present, and recent grader feedback. Require a strict JSON array whose entries contain:

json
{
  "severity": "HIGH",
  "kind": "spec-violation",
  "gap": "one line",
  "spec_anchor": "exact text or MISSING",
  "deliverable_anchor": "exact text or MISSING",
  "fix_suggestion": "specific repair"
}

Allowed kinds include spec-violation, historical-risk, ambiguity-unresolved, format-mismatch, source-grounding-risk, voice-register-drift, and personal-vs-source-imbalance.

Require checks for thesis/prompt fit, uncited source overlap, citation/reference consistency, voice, source-personal balance, and every rubric criterion. Save audit/round-N.json atomically. Repair HIGH gaps and rerun both deterministic verification and audit, at most three rounds. Remaining HIGH gaps produce error.

Stage 7: humanizer handoff

If the overlay enables humanization, invoke the Codex canvas-humanizer skill with absolute paths:

text
draft_path=<work>/draft/essay.pre-humanizer.docx
output_path=<work>/draft/essay.docx
voice_register=<overlay value>
course_id=<course_id>
assignment_id=<assignment_id>
work_dir=<stable work directory>

The humanizer is a local-file transformation. After it returns, rerun word count, citation matching, placeholder, structure, and source-grounding checks. If the transformation fails, preserve the pre-humanizer draft as draft/essay.docx, record the diagnostic in result metadata, and continue only if the verified original draft is intact.

If humanization is disabled, copy the verified pre-humanizer draft to the canonical draft/essay.docx.

Stage 8: final result

Open the canonical DOCX one last time, confirm it is non-empty, and ensure verification.log has no executable FAIL. Then write:

python
from src.course_artifacts import write_course_result

write_course_result(
    work_dir,
    status="draft_ready",
    draft_path=work_dir / "draft" / "essay.docx",
    notes="Verified essay draft; no Canvas mutation performed.",
    metadata={
        "skill": "canvas-essay",
        "verification_log_path": str(work_dir / "verification.log"),
        "humanizer_applied": humanizer_applied,
        "audit_rounds": audit_rounds,
    },
)

First-run stage mode

Honor a single-stage invocation only when <work_dir>/.first_run_stage_by_stage exists. Supported stages are parse-spec, load-samples, research, outline, draft, verify, audit, humanize, and output. Write stages/<stage>.done and stop. Daily execution runs the complete pipeline.

© X-isdoingreat, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/canvas-essay of X-isdoingreat/canvas-pilot.

Open the folder on GitHubat commit 6b79d5b

Compare with similar skills

Canvas Essay next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Canvas Essay compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Canvas Essay this skillX-isdoingreat/canvas-pilot125—~2.2kAutomated safety check: PassAGPL-3.0
Humanize EnglishAnastasiyaW/codex-claude-code-config154—~1.8kAutomated safety check: PassMIT
HumanizerAzure-Samples/interview-coach-agent-framework17338 repos~5.8kAutomated safety check: PassMIT
Avoid AI Writingconorbronsdon/avoid-ai-writing4.9k3 repos~8.1kAutomated safety check: PassMIT
User-Facing Text Cleanupguillaumemeyer/watermarks-remover24k—~3.5kAutomated safety check: PassMIT
Install Anti Sloptrycompai/crm11k1 repos~881Automated safety check: PassMIT

Similar skills

  • Humanize English

    AnastasiyaW/codex-claude-code-config

    Edit English drafts for clear, natural language while preserving facts, uncertainty, technical meaning, citations and genre.

    154 GitHub stars~1.8k tokensUpdated yesterday
    Writing & ContentAuto-check passed
  • Humanizer

    Azure-Samples/interview-coach-agent-framework

    Official

    Remove signs of AI-generated writing from text. An agent skill from Azure-Samples/interview-coach-agent-framework.

    173 GitHub starsUsed in 38 repos~5.8k tokens
    Writing & ContentAuto-check passed
  • Avoid AI Writing

    conorbronsdon/avoid-ai-writing

    Audit and rewrite content to remove AI writing patterns ("AI-isms").

    4.9k GitHub starsUsed in 3 repos~8.1k tokens
    Writing & ContentAuto-check passed
  • User-Facing Text Cleanup

    guillaumemeyer/watermarks-remover

    Audits prose for invisible Unicode characters and rewrites it while keeping facts, citations, code and required disclosures unchanged and the writer's voice intact.

    24k GitHub stars~3.5k tokensUpdated 2 days ago
    Writing & ContentAuto-check passed
  • Install Anti Slop

    trycompai/crm

    Install and configure the anti-slop Oxlint plugin in a local TypeScript or JavaScript repository.

    11k GitHub starsUsed in 1 repo~881 tokens
    Writing & ContentAuto-check passed
  • Stop Slop

    Xe/site

    Remove AI writing patterns from prose. An agent skill from Xe/site.

    732 GitHub starsUsed in 8 repos~423 tokens
    Writing & ContentAuto-check passed

More from X-isdoingreat/canvas-pilot

All 32 skills in this repo
  • Daily Work Tweet

    X-isdoingreat/canvas-pilot

    A skill your agent uses when verified work from today or another day should become an X/Twitter post, build-in-public update, ship log, or bilingual draft.

    125 GitHub stars~1.6k tokensUpdated 2 mo ago
    Auto-check passed
  • Canvas Awkward Syntax

    X-isdoingreat/canvas-pilot

    A skill your agent uses when a short local academic draft needs role-aware syntax diversification while preserving meaning, locks, source grounding, rubric-critical openings, and document structure.

    125 GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Canvas Cron

    X-isdoingreat/canvas-pilot

    A skill your agent uses when managing Canvas Pilot schedules: install, inspect, pause, change, delete, or safely test scheduled scans and runs.

    125 GitHub stars~2.1k tokensUpdated 2 mo ago
    Auto-check: notes
  • Canvas Generic

    X-isdoingreat/canvas-pilot

    A skill your agent uses for an approved Canvas assignment that no specialized course skill can handle.

    125 GitHub stars~2.4k tokensUpdated 2 mo ago
    Auto-check passed
  • Canvas Humanizer

    X-isdoingreat/canvas-pilot

    A skill your agent uses when a local academic draft needs a meaning-preserving humanizing pass with less uniform syntax while retaining rubric, source, lock, voice, and length constraints.

    125 GitHub stars~1.8k tokensUpdated 2 mo ago
    Auto-check passed
  • Canvas Humanizer Loop

    X-isdoingreat/canvas-pilot

    A skill your agent uses when a local draft needs repeated canvas-humanizer passes with independent meaning, structure, citation, voice, and rubric-damage checks.

    125 GitHub stars~1.7k tokensUpdated 2 mo ago
    Auto-check passed

Questions about Canvas Essay

What does Canvas Essay do?

A skill your agent uses for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay. Canvas Essay is an agent skill from X-isdoingreat/canvas-pilot. Use for an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay.

When should I use Canvas Essay?

Canvas Essay fits situations like: an approved long academic-writing assignment routed by canvas-execute after the deterministic writing router selects essay; tasks that involve Humanizing AI text.

How do I install Canvas Essay in Claude Code?

Run `npx skills add X-isdoingreat/canvas-pilot --skill canvas-essay -a claude-code`. Or copy the skill folder (.agents/skills/canvas-essay in X-isdoingreat/canvas-pilot) into .claude/skills/canvas-essay in your project. Claude Code loads it when a task matches its description.

How do I install Canvas Essay in Codex?

Run `npx skills add X-isdoingreat/canvas-pilot --skill canvas-essay -a codex`. Or copy the skill folder (.agents/skills/canvas-essay in X-isdoingreat/canvas-pilot) into .agents/skills/canvas-essay in your project. Codex loads it when a task matches its description.

Can I use Canvas Essay in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add X-isdoingreat/canvas-pilot --skill canvas-essay -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/canvas-essay, .gemini/skills/canvas-essay, .github/skills/canvas-essay and .opencode/skills/canvas-essay in your project.

What does Canvas Essay need to run?

SKILL.md names no scripts, command-line tools or credentials: Canvas Essay is instructions for the agent only. Our summary lists: Python 3.

Does Canvas Essay access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Canvas Essay safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Canvas Essay use?

Canvas Essay is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Canvas Essay use?

About 2.2k tokens (SKILL.md is roughly 9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Canvas Essay?

Skills that share tags, products or a category with Canvas Essay: Humanize English (AnastasiyaW/codex-claude-code-config, 154 stars), Humanizer (Azure-Samples/interview-coach-agent-framework, 173 stars), Avoid AI Writing (conorbronsdon/avoid-ai-writing, 4.9k stars) and User-Facing Text Cleanup (guillaumemeyer/watermarks-remover, 24k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Canvas Essay?

X-isdoingreat (a GitHub user) maintains it in X-isdoingreat/canvas-pilot, which has 125 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on July 31, 2026.

Source: X-isdoingreat/canvas-pilot on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.