DEV Community: Eliot S

Free vs Paid AI Writing Tools: What the Difference Looks Like on a CS Assignment

Eliot S — Mon, 20 Jul 2026 12:28:33 +0000

In May, I had a 1,400-word software ethics paper due in 48 hours. Drafted the whole thing with a free AI tool, touched up maybe two paragraphs, fixed some clunky phrasing, and hit submit. Two days later: "Turnitin flagged your submission with a high AI probability score."

So that was the end of my free-is-probably-fine era.

I didn't stop using AI. That's not where this story goes. What changed was I started paying attention to the real gap between free and paid tools, because it turns out that gap is about more than monthly word limits. It shows up in the output itself, and that matters a lot when you're submitting anything with real technical depth.

For most of this semester I've been comparing free AI writing tools for students against their paid equivalents, specifically on CS writing: lab reports, algorithm analysis papers, technical reflections, discussion posts, README docs. Below is what I found, not what the landing pages say.

Why free AI writing tools for students dominate

The math is obvious. You're broke, you have a ten-page OS concepts paper due Thursday, and $20/month on a writing tool you'll use three times a semester makes no sense.

ChatGPT free, Gemini free, Claude free, plus dozens of smaller tools advertising themselves as AI writing assistants, all run on an email address and five minutes. For short, low-stakes stuff, they work. Once you need output that can pass a detection scan or genuinely sound like a person wrote it, the story shifts.

"Perfectly functional" has a ceiling, and that ceiling tends to appear exactly when you need the tool most: the paper worth 30% of your grade that goes through Turnitin.

What free tiers produce on a CS assignment

Pick a standard CS writing assignment: a 900-word reflection on the ethical implications of biased training data. Free tools give you the same thing every time, and it's pretty easy to spot.

The output reads like an AI summarizing Wikipedia. Technically correct, completely forgettable. It'll hit the obvious points: fairness, representation, accountability. But it'll say nothing that distinguishes your answer from the 200 other students who ran a similar prompt. There's no angle. No specific argument. Just the surface-level version of the topic restated in paragraph form.

Then there's the structure issue. Ask an AI about "three ethical challenges in machine learning" and the free output will have three sections literally titled "Challenge 1," "Challenge 2," and "Challenge 3." No synthesis, no through-line, no moment where the paper makes a claim. The prompt became headings.

The sentence rhythm is where it really falls apart. Cadence too even. Vocabulary sitting a register higher than what a student would write. Transitions like "Furthermore" and "It is worth noting that" appearing every third sentence without fail. It gets detected as AI because it reads like AI: there's no inconsistency in it, which is itself suspicious.

On Discord or in a casual personal project, none of that matters. On Turnitin, it matters a lot.

I've run the same prompt through several free tools and checked output at the document level. Unedited, they land at 70-90% AI probability. Light editing, varying sentence structure, swapping vocabulary, breaking up the rhythm, gets some down to 50-60%. Still borderline for anything high-stakes.

Where paid tiers earn their price

Not all of them do, to be clear. Some of what you're paying for is real. Some of it is just better branding on the same underlying model.

Context windows are the real one. Paid tools hold more of your paper in context while generating, which cuts down on the contradictions and repetition that show up when a free tool effectively forgets what it wrote three paragraphs ago. Free tiers often cap at a few thousand tokens: enough for a 500-word response, not enough for a 1,500-word lab report where the conclusion needs to reference specific claims from section two.

Instruction-following is the other big gap. Tell a paid model to write for "a second-year CS student explaining cache coherence to a non-technical reader" and it adjusts register, avoids jargon, and maintains that adjustment for the whole document. The free equivalent typically starts okay and drifts back into textbook language by paragraph three. That drift is what kills you on reflective writing and technical essays, where voice and consistency are what separates a passable paper from an obvious AI dump.

On detection: nothing is undetectable, but paid tools built for academic writing produce output with more sentence variety, more natural paragraph rhythm, and fewer of the statistical patterns that detection tools are trained to catch. On a 600-word algorithm analysis prompt, the free output came back at 84% AI probability on first run. Same prompt on a paid tool: 41%. One editing pass got it under 30%.

Then there's the time math. Editing a free output usually means rewriting 40-50% of the content to get it somewhere passable. When the starting point is better, you're touching maybe 15-20%. That compounds across a semester.

Side-by-side on three CS writing tasks

Lab report introduction (200 words)

Free output: technically accurate, appropriately formal, three consecutive sentences starting with "The." Detection probability: 79%.

Paid output: same technical content, more varied sentence structure, one deliberate sentence fragment for emphasis. Detection probability: 38%.

Editing time to reach a submittable draft: roughly 15 minutes for the free output, 5 for the paid. That gap widens considerably for longer assignments.

Technical reflection on a failed project (500 words)

This is where it's most obvious. Reflective writing needs voice, and free tools default to corporate-sounding reflection: "challenges were encountered," "lessons were learned," "future iterations will benefit from." Passive, vague, and flagged every time.

Paid tools with a first-person or personal essay mode get noticeably closer to something that sounds real. You still have to inject the specifics: what went wrong, what you felt when the deployment broke at 2am. But the scaffolding is much closer to human writing, which cuts down on how much you need to rewrite before it sounds like you.

GitHub README (200-400 words)

Free tools are mostly fine here. Detection isn't really a concern in a README anyway. A free model handles "write a README for a Flask REST API with JWT authentication, Python 3.11, and PostgreSQL" almost as well as a paid one. Minimal difference for documentation-only use.

If READMEs and code documentation are all you're generating AI writing for, the free tier probably covers it. I wrote a full breakdown of the best tools specifically for this use case in Best Free AI Writing Tools for Computer Science Students on my Substack, if that's what you're after.

Free AI writing tools for students: when they're enough

The answer depends on the assignment, not on the tool.

For low-stakes work: discussion posts under 300 words, peer review responses, short reflections that aren't weighted heavily. Free is fine. Edit once, submit. Detection scores matter a lot less when a professor isn't cross-referencing the paper against your in-class writing samples, and most low-weight discussion posts aren't worth that level of scrutiny.

500-1,000 word papers and major discussion boards are where it gets conditional. Free tools work, but you need to edit hard. Rewrite at least 40% of what gets generated, vary sentence lengths, cut vocabulary that doesn't match how you write. It's not faster than starting from scratch. It's faster than staring at a blank page.

Anything over 1,000 words going through Turnitin, or anything a professor has flagged as monitored? Free tools are a liability. At that point you're doing a near-full rewrite anyway, which means the AI is giving you an outline and rough phrases, not a draft. A paid tool with better baseline output saves more editing time per month than it costs.

The thing nobody mentions about free tiers

Run the same prompt twice on a free tool. The quality difference between those two outputs is often significant: one will be solid, the next will be stiff and generic. Paid tiers show variance too, but the floor is higher and the swings are smaller.

When you're under deadline and can't spend time running the same prompt four times to find the good output, that consistency gap matters. Free tools sometimes get you there. Paid tools get you there more reliably.

The verdict

Paid AI writing tools produce better output on CS assignments. The detection numbers are lower, the instruction-following is tighter, and editing time is shorter. Is it worth paying for on a student budget? That's the real question.

For most CS students, one paid tool used selectively for high-stakes assignments makes sense. Two or three major papers a semester where you cut editing time and reduce detection risk can justify $10-15/month. Everything else: READMEs, portfolio blog posts, low-stakes coursework. Free AI writing tools for students handle those well enough.

You just need to know which category you're dealing with before you submit.

ngl, I figured this out the hard way. Hopefully this saves you the Turnitin email.

AI Humanizer Comparison: What Actually Changes When You Run Text Through Them

Eliot S — Mon, 13 Jul 2026 14:05:59 +0000

Last semester I got tired of guesswork and made a spreadsheet. Same 500-word paragraph, six different tools, back to back. None were detection scores. The actual output was which sentences got rearranged, which words switched out, whether the output still read like something a person wrote.

I'd been using these tools for almost two years at that point. And every AI humanizer comparison post I found was the same. Tools. Prices. Star ratings. Nothing about what happened to your writing, which is the only part that matters if you want to understand why some tools work and others don't. So I ran my own test.

The gap between free and paid tools is bigger than people let on. The gap between "swaps words around" and "reorganizes sentences" is also larger. In fact, there's a middle category too, tools that partially rewrite some sentences while leaving others identical, which gives you spotty results and makes you think the tool failed even though it didn't. Knowing what each type does helps make choosing one less random.

What an AI humanizer does to your text (technical version)

Understanding detection before comparing tools helpfully explains exactly what detection measures.

Turnitin and GPTZero look at two things: perplexity (how predictable were each word choice compared to what a language model would have picked?) and burstiness (how much does sentence length vary across a paragraph?). Human-written text scores low because the model takes the statistically likely path with every single word. Burstiness is short sentences here and long ones there. Fragments. Occasional run-ons. Clusters in a narrow band are how AI output works.

Humanizers target one or both. The least expensive way is to use vocabulary substitution. Swap predictable words for less common ones and perplexity increases. Structural rewriting costs more. Break down sentences, rebuild them differently, change where information arrives. Transition phrases such as "Furthermore," and "It is important to note that..." get special attention from many tools today because bro, those are pretty much detector bait at this point.

The problem with just swapping vocabulary: detectors caught up to it. Uncommon words over identical sentence structure can be flagged. Perplexity increases but burstiness stays flat, and that mismatch is now its own signal. The tools that hold up do both passes: different words and different structure.

There's another signal that gets far less attention: argument coherence. AI paragraphs follow a super predictable sequence: claim, support, support, conclusion. Some structural rewriting tools break this by changing where ideas land. That's harder to detect and it's not something any substitution-only tool can replicate.

I went deeper on this with real score comparisons in Best AI Humanizers for College Students: Free and Paid Options Tested if you want the data.

AI humanizer comparison: what the text looked like after processing

Four things tracked per tool: sentences structurally rearranged, words swapped, meaning preserved, output readable.

More surprisingly large than expected were the gaps between free tools and paid tools. The gaps between "words changed" and "sentences rearranged" were also larger than expected. There's a middle category too, tools that partially rewrite some sentences while leaving other sentences entirely intact, which produces spotty results and leads you to think the tool has failed even though it may not have done anything wrong.

Understanding what each type does makes choosing a tool significantly less random.

Is there a free AI humanizer?

Yeah, a handful actually work. Most free tools are either capped at a few hundred words, watermark the output, or run so slow you give up. It is what it is.

Walter Writes has a Lite tier that doesn't require a subscription. For quick tests before submitting or checking whether a tool is worth paying for, it's genuinely useful. I tested a bunch of free options head-to-head in I tested every free AI humanizer I could find with before/after detection scores if you want specifics on each one.

The bigger issue with free tools is consistency. A tool that scores well today might not after the next model update, and free tiers don't always get updated at the same pace. For low-stakes stuff, free is fine. For anything that affects your grade, pay the difference. It's usually not much.

How to 100% humanize AI text?

"100%" is the wrong frame. No tool makes text permanently undetectable across every platform and every future update. Turnitin updates. GPTZero updates. A professor who's graded your work all semester is a fundamentally different kind of evaluation than any software score.

What you can do is get the text statistically indistinguishable from human writing and editorially consistent with your voice. Those are two different jobs. The tool handles the statistical side, perplexity, burstiness, structural variation. You handle the editorial side.

fr fr the biggest mistake I see is running text through a humanizer and submitting it without reading the output. The tool might have introduced a sentence that doesn't fit your argument, or phrasing you'd never actually write. A 15-minute read catches all of that.

My process: generate the draft, run it through a structural humanizer, then spend 15 minutes editing specifically for sentences that don't sound like you. That last step is the one people skip. It's also the step that closes the gap between a low AI score and something a professor flags for style inconsistency. Covered the full editing breakdown in the editing step is where most people lose.

Is there a 100% accurate AI detector?

No. But some are way more useful than others.

Every detection tool has false positive problems. A checker that flags real human writing 30% of the time is just noise. The useful ones are calibrated, show sentence-level breakdowns instead of one overall score, and are upfront about confidence levels.

Proofademic does sentence-level analysis. You get individual sentences flagged with reasons, not just "40% AI." That matters because "40%" tells you there's a problem somewhere. Sentence-level output tells you it's your intro paragraph and the rest reads clean. You know exactly what to fix.

For high-stakes assignments, that difference is significant. It also builds a feedback loop over time. You start noticing which sentence structures keep getting flagged and avoid them before you even run detection. That's worth more than any single score.

One thing this AI humanizer comparison won't tell you six months from now

Tools change. Most comparison posts skip this part because it makes the whole post feel less definitive.

A tool that scored well in my tests last semester might not perform the same today. Turnitin updates its detection model. GPTZero updates. The tools that stay useful are the ones doing real structural rewrites and staying current, not tools that gamed one pattern and have been running the same model since.

I re-run my test paragraph every few months to see if results shifted. Occasionally they do. I wrote about how keeping your voice consistent through this whole process, not just chasing detection scores, is the long-term move in how to make AI sound like human. A tool that outputs structurally different text can still get you flagged if it doesn't sound like you. The detection problem just moves from software to professor.

The AI humanizer comparison that actually matters isn't which tool scores best on one test. It's which tool is still working in six months, still doing real structural rewrites, and still producing output that doesn't read like a thesaurus ran it. That list stays short.

AI for CS Assignments: How I Survive Technical Writing (Without Completely Dreading It)

Eliot S — Fri, 10 Jul 2026 10:44:03 +0000

Sophomore year. My algorithms professor dropped a 1,500-word reflection assignment about the ethics of AI in software development on a Monday morning. The class is called Data Structures and Algorithms. There's not supposed to be a reflection assignment. I stared at the prompt for a full minute, confused about what any of it had to do with binary trees, and then I did what I now do for every writing assignment: I opened an AI tool and started talking to it like it was a very patient tutor who could also write.

I'm a CS student. I'm not bad at school. I'm just bad at writing, and I've stopped pretending that's going to change before I graduate. My brain works in logic, systems, and patterns. Prose is not my thing. Using AI for CS assignments isn't a moral position for me. It's just a time allocation decision, the same way using Stack Overflow to debug is a time allocation decision. I'm not going to build a binary search tree from scratch when documentation exists. I'm not going to write a 1,500-word ethics reflection from scratch when AI exists.

If you're a CS student who has the same relationship with writing that I do, here's a breakdown of how I approach it.

Why AI for CS assignments is different from AI for other subjects

The thing nobody tells you before you try this is that AI outputs for technical writing are weirdly inconsistent. I learned this the hard way my freshman year.

For writing-heavy majors, AI can probably produce a passable essay with minimal editing. For CS writing assignments, that's less reliable. CS professors write prompts that assume you've been paying attention in class. They want you to connect concepts, reference the specific material, and sometimes argue a position using the exact framework they lectured on.

Generic AI output misses that context completely. I've gotten drafts that were technically correct, coherent, and completely useless because they didn't engage with the actual course content. My professor wanted me to analyze an algorithm design decision using the trade-off framework from week four. The AI gave me a thoughtful general essay about algorithmic complexity. That's not the same thing.

So the first thing I figured out is that using AI for CS assignments requires you to give it something to work with. A blank prompt gets you a blank-feeling essay. You have to do some upfront work to get useful output.

Setting up AI for CS assignments: the context dump

My process starts with what I call a context dump. Before I write a single word of the actual prompt, I paste in everything relevant: the assignment instructions, any readings or slides the professor referenced, my own notes from class if they're halfway readable, and a rough bullet list of the points I want to make.

That last part matters more than it sounds. Even if my bullet points are rough and incomplete, having them there shifts the output from generic to specific. The AI is building on my material instead of inventing its own. The result engages with the course content because I gave it the course content.

For a 1,500-word assignment, my context dump probably takes 20-30 minutes. That's not nothing, but it's way less than writing from scratch, and the output is significantly better.

Some assignments have less context to work with. Discussion posts, for example, are often just "respond to this question in 200-300 words." Those I treat differently. Less setup, lighter editing. I'm not going to spend 30 minutes preparing for a 200-word discussion post.

The actual workflow once you have a draft

Getting a draft is step one. The draft is almost never submittable without editing, and I've gotten into trouble when I treated it like it was.

The issues I run into consistently are:

Tone mismatch. AI writes formally. I write casually. My in-class writing samples exist, and professors aren't stupid. If there's a significant style gap between how I write in a timed quiz and how I write in a take-home essay, someone might notice. So I edit for tone first. I cut the academic vocabulary I'd never use and replace it with how I'd phrase things.

Missing specificity. Even with a context dump, AI sometimes produces sentences that are technically accurate but vague. "This design decision involves trade-offs between time and space complexity" is not useful. My professor knows that. What they want is for me to say which trade-off, why it matters in this specific context, and what I think about it. I add that layer manually.

Weird paragraph length. AI tends to write in uniform paragraph sizes, which looks artificial. I break things up or combine sections based on what makes sense for the argument.

Transition phrases I'd never say. "It is worth noting that..." No. I delete these and replace them with something that sounds like me or nothing at all.

The editing pass takes me maybe 30-40 minutes depending on the assignment. So total time investment for a 1,500-word essay is roughly an hour to an hour and a half. That's still significantly less than writing from scratch, which for me would be three or four miserable hours and a worse result.

The detection step

I want to talk about this because it's the part that adds the most anxiety, and I've learned enough about it to be less anxious than I used to be.

Most universities are using AI detection tools that work by analyzing patterns in text that are statistically associated with AI-generated writing. The tools aren't perfect. They flag human writing sometimes. They miss AI writing sometimes. The threshold matters. A paper that comes back 40% AI-flagged is very different from one that comes back 90% flagged.

My edited drafts, after the kind of editing I described above, generally come back in a range that doesn't trigger concern. The tone edits and specificity additions change the text enough that the statistical patterns shift. But I still check before I submit anything major, because I'd rather know than not know.

I wrote more about the mechanics of how detection works in a piece I published a few months ago. If you want to understand what the tools are doing, that's probably worth reading before you submit something high-stakes.

The short version is: detection is probabilistic, not certain. A flagged paper is not automatic proof of AI use. An unflagged paper is not a guarantee of safety. The risk is real but it's manageable if you edit seriously.

Where AI for CS assignments breaks down

There are assignment types where this workflow doesn't work well, and I've learned to identify them early.

Anything with a specific argument the professor wants. If the assignment is "argue for or against position X using the framework from this week's lecture," and I haven't internalized that framework, the AI output is going to be hollow. I can tell. My professor will definitely be able to tell.

Short writing that has to match your in-class voice closely. Some professors use short reflections throughout the semester partly to build a record of your writing style. Those are the assignments where the gap between an AI-assisted paper and your natural voice is most visible and most risky.

Anything with citations from sources the professor assigned. AI will hallucinate citations with confidence. I've caught it inventing papers that don't exist, inventing page numbers for real papers, and attributing quotes to the wrong author. For anything that requires real citations, I pull the sources myself and verify every single one.

Oral follow-up. Some professors ask students to come in and discuss their papers. If you can't talk about what you wrote, that's a bad situation. I make sure I understand everything in the draft before I submit it.

Using AI for CS assignments beyond coursework

This part I enjoy more than the academic stuff.

My GitHub READMEs used to be three lines. Project name, what it does, how to run it. That's it. I knew this was bad but I couldn't make myself write more. Now I use the same basic workflow: context dump (the code, what the project does, any interesting technical decisions I made), let the AI draft something, edit for my voice, and publish.

The result looks like I'm a developer who can explain his own projects. Which is apparently a skill recruiters care about, even though it's not what I thought I was signing up for when I started this degree.

Same with documentation. I'm working on a side project right now that I want to put in my portfolio, and the docs need to be readable. AI handles the first pass. I handle the part that requires knowing what the code does and why I made specific choices.

For portfolio work, detection is less of a concern. Nobody's running recruiter AI detectors on GitHub READMEs. But sounding human still matters because a robotic README signals low effort on the one artifact that's supposed to show you off.

My take on where this is headed

I think the current cat-and-mouse situation between AI tools and detection tools is going to get more complicated before it gets simpler. Detection is improving. AI output is also improving. Universities are updating their policies semi-regularly, mostly in ways that are inconsistent and hard to keep up with.

The practical reality for a student right now is that the risk is real but manageable with a serious editing process. The students I've seen get flagged were mostly the ones who ran a bare AI output through submission without editing it. That's not a good strategy.

I also believe the line between "using AI" and "using any other tool to help you work" is blurry in a way that a lot of institutional AI policies haven't caught up with. I use AI the same way I use syntax highlighters, linters, and autocomplete. It's a tool that makes me faster at a task. The task still requires my judgment, my context, and my editing.

That's the part that makes AI for CS assignments work when it works. The tool gets you to a draft. The draft is your problem.

AI Detector Accuracy Test: I Built a Python Script to Send the Same Essay to 5 Tools at Once

Eliot S — Wed, 08 Jul 2026 14:06:25 +0000

Last semester I pasted the same essay into two detectors back to back and got 82% on one, 31% on the other. No edits. Same paste. Within the same hour.

I stared at that for a while. Like, which one do I trust? Both? Neither? If I'd only checked one, I'd have a completely different read on my actual situation. That's when I decided manual tab-switching wasn't going to cut it for a real AI detector accuracy test.

So I spent a Saturday morning building a script. This is that script plus what I found when I actually ran it.

Why I bothered automating the AI detector accuracy test

Honestly, two reasons.

The boring one first: speed. If you're comparing versions of the same text (raw, edited, humanized), that's five tools times three versions equals fifteen paste jobs. I don't have that kind of patience and I suspect you don't either.

The less obvious one is that these tools aren't consistent even with themselves. I pasted the same block of text into ZeroGPT twice, no changes at all, and got slightly different numbers. Not dramatically different, but different. If you're anywhere near a threshold that matters, that variance is a problem. Running everything in one script simultaneously at least controls for that. Not a perfect solution, but better.

For my test I used three versions of the same essay:

Version A: Straight from GPT-4o, zero editing
Version B: About 20 minutes of hand editing
Version C: Processed through a humanizer tool

The five detectors

GPTZero — my university writing center literally name-dropped this one in their updated AI policy email. So that's probably what people in my department are running.
Originality.ai — has an actual documented API, used a lot in publishing
Winston AI — good docs, and you can get per-sentence breakdowns which turns out to be useful
ZeroGPT — free, no account, but I'm using an unofficial endpoint. Could stop working tomorrow, no idea.
Copyleaks — handles both AI detection and plagiarism in one go. I'm not implementing it fully here because the OAuth flow adds a bunch of boilerplate that's not really the point of this post.

The code

The main thing is aiohttp so all four requests fire simultaneously instead of waiting in sequence. Install it first:

pip install aiohttp

Then the full script:

import asyncio
import aiohttp
import json
from dataclasses import dataclass

@dataclass
class DetectionResult:
    tool: str
    score: float        # 0.0 = human, 1.0 = AI
    error: str = None

API_KEYS = {
    "gptzero":     "YOUR_GPTZERO_KEY",
    "originality": "YOUR_ORIGINALITY_KEY",
    "winston":     "YOUR_WINSTON_KEY",
}

ESSAY = """Paste your essay text here."""


async def check_gptzero(session: aiohttp.ClientSession, text: str) -> DetectionResult:
    url = "https://api.gptzero.me/v2/predict/text"
    headers = {
        "x-api-key": API_KEYS["gptzero"],
        "Content-Type": "application/json",
        "Accept": "application/json",
    }
    payload = {"document": text, "multilingual": False}
    try:
        async with session.post(url, headers=headers, json=payload) as resp:
            data = await resp.json()
            score = data["documents"][0]["completely_generated_prob"]
            return DetectionResult(tool="GPTZero", score=score)
    except Exception as e:
        return DetectionResult(tool="GPTZero", score=0, error=str(e))


async def check_originality(session: aiohttp.ClientSession, text: str) -> DetectionResult:
    url = "https://api.originality.ai/api/v1/scan/ai"
    headers = {
        "X-OAI-API-KEY": API_KEYS["originality"],
        "Content-Type": "application/json",
    }
    payload = {"content": text, "aiModelVersion": "1"}
    try:
        async with session.post(url, headers=headers, json=payload) as resp:
            data = await resp.json()
            return DetectionResult(tool="Originality.ai", score=data["score"]["ai"])
    except Exception as e:
        return DetectionResult(tool="Originality.ai", score=0, error=str(e))


async def check_winston(session: aiohttp.ClientSession, text: str) -> DetectionResult:
    url = "https://api.gowinston.ai/functions/v1/predict"
    headers = {
        "Authorization": f"Bearer {API_KEYS['winston']}",
        "Content-Type": "application/json",
    }
    payload = {"text": text, "sentences": False}
    try:
        async with session.post(url, headers=headers, json=payload) as resp:
            data = await resp.json()
            return DetectionResult(tool="Winston AI", score=data["score"] / 100)
    except Exception as e:
        return DetectionResult(tool="Winston AI", score=0, error=str(e))


async def check_zerogpt(session: aiohttp.ClientSession, text: str) -> DetectionResult:
    # unofficial — may break at any time
    url = "https://api.zerogpt.com/api/detect/detectText"
    headers = {"Content-Type": "application/json"}
    payload = {"input_text": text}
    try:
        async with session.post(url, headers=headers, json=payload) as resp:
            data = await resp.json()
            score = data["data"]["fakePercentage"] / 100
            return DetectionResult(tool="ZeroGPT", score=score)
    except Exception as e:
        return DetectionResult(tool="ZeroGPT", score=0, error=str(e))


async def run_all_detectors(text: str) -> list[DetectionResult]:
    async with aiohttp.ClientSession() as session:
        tasks = [
            check_gptzero(session, text),
            check_originality(session, text),
            check_winston(session, text),
            check_zerogpt(session, text),
        ]
        return await asyncio.gather(*tasks)


def print_results(results: list[DetectionResult], version_label: str):
    print(f"\n{'=' * 50}")
    print(f"Version: {version_label}")
    print(f"{'=' * 50}")
    print(f"{'Tool':<22} {'Score':>8}  {'Verdict':>10}")
    print("-" * 44)
    for r in sorted(results, key=lambda x: x.score, reverse=True):
        if r.error:
            print(f"{r.tool:<22} {'ERROR':>8}  {r.error[:20]}")
        else:
            pct = r.score * 100
            verdict = "AI" if pct > 50 else "Human"
            print(f"{r.tool:<22} {pct:>7.1f}%  {verdict:>10}")


if __name__ == "__main__":
    versions = {
        "Version A (raw GPT-4o output)": ESSAY,
        # swap in your other versions:
        # "Version B (light edits)": ESSAY_B,
        # "Version C (humanized)":   ESSAY_C,
    }
    for label, text in versions.items():
        results = asyncio.run(run_all_detectors(text))
        print_results(results, label)

Version A output:

==================================================
Version: Version A (raw GPT-4o output)
==================================================
Tool                     Score     Verdict
--------------------------------------------
Originality.ai          94.0%          AI
Winston AI              88.0%          AI
GPTZero                 81.0%          AI
ZeroGPT                 74.0%          AI

AI detector accuracy test results across all three versions

Here's what I got:

Version A — Raw GPT-4o:

Originality.ai: 94%
Winston AI: 88%
GPTZero: 81%
ZeroGPT: 74%

Version B — Lightly edited by hand:

Originality.ai: 71%
Winston AI: 62%
GPTZero: 58%
ZeroGPT: 43%

Version C — Humanized:

Originality.ai: 31%
Winston AI: 28%
GPTZero: 24%
ZeroGPT: 19%

The Version A spread killed me a little. 74% to 94% on the exact same raw GPT-4o output. That range matters because schools draw the line in different places: 80% at some institutions, 50% at others, 60% at others depending on who wrote the policy that week. You can pass one bar and fail another on the same document.

Version B was the disappointing one. I actually put time into those edits — went through every paragraph, tried to break up the cadence, cut some sentences, added my own phrasing. Still got flagged by three out of four. ZeroGPT was the only one that dipped under 50%. Twenty minutes of editing barely moved Originality.ai. Wasn't expecting that.

Version C passed everything. Still a 12-point spread (19% to 31%) but well below any real threshold. The variance didn't disappear though. These four tools are clearly measuring different things.

Most accurate AI detector 2026: what I actually found

Nobody's running away with this. That's the honest take from my data and the benchmarking stuff I've read elsewhere.

If I had to pick one for catching raw, unedited AI output: Originality.ai. It came in highest on Version A by a margin and was the last to budge as I edited. But that aggression is a double-edged thing. I've seen it flag heavily stylized human writing that just happens to be formal and structured. If you're testing a student paper from someone who writes in a clean, academic style, I'd double-check with a second tool before acting on that result.

GPTZero was the most relaxed. Lowest false positive rate of the four, which probably reflects how it was designed. Specifically for academic submissions where wrongly flagging a real student is a much bigger deal than missing a borderline AI piece. Catches less, but what it catches it's more confident about.

Winston AI landed somewhere in between. Comparable to GPTZero on raw output but less aggressive on edited text. Per-sentence view is genuinely handy if you want to see which paragraphs pushed the needle instead of just getting a single number and guessing.

ZeroGPT? All over the place. Free, no sign-up required, which is why it's everyone's first stop. But the variance makes it basically useless for anything where the stakes are real.

The question "most accurate AI detector 2026" kind of assumes there's a right answer. There isn't. High detection sensitivity and low false positive rate pull in opposite directions. You're always trading one for the other.

AI detector comparison: why the same text scores differently

When I first saw the results I thought one of the tools had to be wrong. But that's not really how this works.

These things aren't running the same model. Some are built around perplexity and burstiness, meaning how predictable the word choices are and how uniform the sentence lengths are. GPT-4o output is low-perplexity almost by definition. The model is trained to pick the most probable next token, which makes the text statistically smooth in ways human writing isn't. We're messier. We change our minds mid-sentence, pick words for rhythm, write shorter when tired.

Other tools look at semantic patterns instead — whether the writing hedges, goes off-topic, self-corrects, circles back. That stuff shows up in human writing because we're thinking while typing. AI generates from a prompt in one pass and has no reason to qualify or digress.

So this AI detector comparison isn't really about which tool is better. Originality.ai weights semantic signals more heavily, which is why it nails raw output but sometimes overcorrects on human writing that's direct and well-structured. GPTZero's calibration is different because it was trained on a different population of text.

Paste the same essay into four tools, get four different scores — you're probably looking at genuinely borderline content. That's not a calibration error. That's what the gray zone looks like.

Can Turnitin detect ChatGPT?

Yes. And it's not in this script, which is the more important part.

Turnitin launched their AI detection feature in April 2023. Updated a few times since. Covers ChatGPT, Claude, Gemini, and the usual suspects. Their own published figures say something like 98% accuracy on unedited AI output and a 1% false positive rate on human writing. Take self-reported numbers with appropriate skepticism, but they're probably in the right ballpark.

It's not in this script because there's no public API. Their detection is baked into the submission pipeline. Canvas, Blackboard, whatever LMS your school uses. The only way to test against Turnitin is to actually submit.

I found this out the hard way. Ran something through this script, got a 22% on GPTZero, submitted it, got a 71% back from Turnitin. That was a bad day. Their model has context I don't — submission history, cross-comparison patterns, document metadata. It's doing something different from the external tools. Pre-checking with this script is still worth it, but a clean result here is not a Turnitin guarantee.

What this AI detector accuracy test tells you (and what it doesn't)

The main thing: one tool isn't enough. The variance is too wide to make decisions from a single number.

Four tools all flagging high? Real signal. The text is probably still close to raw output and needs more work. Four tools splitting 50/50? Genuine gray zone, and your actual risk depends on which specific tool is running on the other end.

The script is good for:

Cross-checking whether something is flagging consistently
Seeing how sensitive different detectors are to the specific edits you're making
Cutting the manual tab-switching down to one function call

The editing and humanization side — what actually moves scores — is a longer topic. I went into it on my Substack, specifically the part of the process most people skip entirely, which is also why a lot of people are still getting flagged even after running their text through a humanizer once.

The script above is minimal by design. Per-sentence Winston output, Copyleaks integration, and CSV batch logging are reasonable things to bolt on if you need them.