AI Docstring Generator Showdown: Copilot's Free Tier Wins, Standalone Startups Nearly Wiped Out

Every Python developer has lived this moment: you open a file, see a function called process() with three parameters and not a single line of docstring, and silently curse the person who wrote it. In 2026, that person is usually an AI Agent.

What nobody warned us about in advance: documentation debt didn't disappear with the spread of coding assistants — it just changed shape. Code ships faster than ever, and undocumented code ships just as fast — because the way an Agent writes a function is roughly the same as the way it writes a shopping list.

Over the past few weeks, one developer ran the current generation of AI docstring generators through the same test pipeline: an inherited 60-module Flask API, a medium-sized FastAPI service with clean type hints, and a small CLI tool with almost no type annotations. Same test functions, three docstring styles (Google, NumPy, Sphinx), and one question per tool: would I merge this output without changing a single word?

Copilot Is Still the Default, and the Free Tier Is Genuinely Enough

Copilot is the most widely deployed docstring tool of 2026, not because anyone built it for documentation, but because documentation is simply a side effect. Select a function, ask it to generate a docstring, and it produces Google- or NumPy-style docs whose content actually reflects the code's behavior — because it has already read the rest of the file, your tests, and even adjacent modules.

GitHub's official pricing page shows: Free tier $0, with 2,000 completions per month and limited chat; Pro $10/month; Pro+ $39/month; Max $100/month.

The most surprising conclusion: for most indie developers' docstring work, the free tier is already enough. Two thousand completions a month sounds like little, but documenting a function consumes one completion, not one per keystroke. Output quality is stable on well-typed code and mediocre on dynamic legacy code — the same is true at paid tiers.

The downsides are clear too: Copilot only documents the function in front of you. No "scan the whole repo and fill the gaps" mode, no coverage percentage, no way to stop undocumented code from reaching the main branch. It's an excellent writing tool and a non-existent enforcement tool.

What is a docstring? A docstring is a string literal written on the first line of a module, function, class, or method definition in Python. It's exposed via the __doc__ attribute and can be automatically extracted by tools like help(), pydoc, Sphinx, and IDE hover tooltips. It's fundamentally different from a regular comment: comments are for people reading the source and are ignored by the interpreter, whereas a docstring is structured metadata readable by programs — which is why it can drive documentation site generation, type checkers (e.g., mypy's --strict checks docstring style), and pytest's test discovery. Google, NumPy, and Sphinx are the three mainstream styles, differing mainly in the layout conventions for parameters and return values: Google style uses indented Args:/Returns:/Raises: blocks, NumPy style uses underlined section headings, and Sphinx style uses :param:/:return:/:raises: fields. Style choice itself doesn't affect functionality, but it affects how downstream toolchains parse the output, so team consistency matters more than which one you pick.

Claude Code: The Best Choice for Batch Documentation

If your real problem is "this repo has 400 undocumented functions," Copilot's one-at-a-time cadence is the wrong shape. Claude Code reads the entire directory tree. Point it at a directory, ask it to fill in all the gaps while preserving existing docstrings, and it chews through the whole backlog in one go.

This was the highest-quality output in the test: it catches Raises clauses, understands that transfer_funds() debits one account and credits another, and writes usage examples that actually run.

On pricing, Anthropic's official page shows Claude Code is included in Claude Pro $17/month (annual, $200 one-time; $20 if billed monthly), Max 5x $100/month, and Max 20x $200/month. You can also go the API route and pay per token, where batch runs on a small repo cost just a few dollars each.

The trade-off: it isn't a docstring tool, it's an opinionated Agent. On one legacy module, it went ahead and "fixed" a subtle bug. The fix itself was correct, but nobody asked it to — and reviewing a diff that's 80% docstring and 20% unrequested refactor is its own kind of work. What a documentation task wants is precisely the predictable behavior of a single command, and an autonomous Agent is precisely not that.

Why do agent-style tools produce "unrequested changes"? The working loop of an autonomous LLM-based Agent like Claude Code is "read context → reason → call tools → observe results → continue," not "execute a fixed command." When it reads a piece of code it considers buggy while filling in docstrings, the model's "helpfulness" tendency pushes it to fix it along the way — because from its perspective, fixing defects is part of making the code better. This is fundamentally different from a traditional batch script: a script does only what you tell it to do; an Agent does what it thinks you ought to do. This is why, in documentation tasks, "predictability" is often valued more than "capability ceiling." Control measures include: explicitly constraining in the prompt "only add docstrings, do not modify any logic code," using read-only permissions or reviewing via git diff, and configuring PR gates in CI that require human approval. Understanding this behavior pattern helps distinguish "the tool is bad" from "the tool is being used in the wrong scenario."

Devin (formerly Codeium/Windsurf): Inline Is Fine, but It's the Wrong Reason to Buy It

The Codeium → Windsurf → Devin merger is complete: windsurf.com/pricing now redirects to Devin's page. Current tiers are Free $0 (light Agent quota, unlimited Tab completion and inline editing), Pro $20/month, Max $200/month, Teams $80/month plus $40 per seat.

Inline docstring quality is decent — roughly on par with Copilot for Python, occasionally better on TypeScript-style code. But the real objection is this: for $20/month you're buying an autonomous Agent platform, and docstrings are a negligible fraction of its feature set. If your goal is documentation, this is the most expensive path to the same output you get from Copilot's free tier.

The Open-Source CLI Route: docstring-ai and Offline Single-File Solutions

On the PyPI side, the most well-received is docstring-ai: MIT-licensed, released April 2026, maintained by a single developer. pip install docstring-ai, point it at a file or directory, choose google, numpy, or sphinx style, and it batch-generates while skipping functions that already have docs. Dry-run mode prints a summary before touching any files — "Generated: 8 / Already had: 3 / Skipped: 2" — and it supports CI out of the box.

The tool itself is $0; the running cost depends on your ANTHROPIC_API_KEY bill — because it needs a key. One-off completions are pocket change; wire it into CI on every push and the API bill becomes a subscription you never signed up for. Still, at this price point, no other batch solution comes close.

Another route is an offline-first single-file CLI: scan finds every undocumented function in the codebase, generate --apply inserts docstrings in place while preserving existing formatting, and check --fail-below 80 fails CI when documentation coverage drops below a threshold. It runs offline by default with no API key, has an optional --llm flag for model-generated text, and also supports README-style API reference generation and JSON export. It's a one-time $49 with no seats and no monthly billing — the only option here that behaves like a product rather than a billing sheet. (Note: the original author discloses that this tool is his own product and includes affiliate links.)

The Docstring Startups That Vanished

Two years ago, this article would probably have started with docstring.io and PyDoc AI. But both sites are unreachable this month, and searching for PyDoc AI now turns up nothing. Stenography — the "auto-document on save" darling — is listed by third-party trackers as probably dead, and its domain won't load either. These tools joined the docstring graveyard, and their business model deserved to die there: a standalone startup charging per seat to do what every general-purpose coding assistant now does for free.

Even Sourcegraph Cody — the standard-bearer for "ask anything about your codebase" — no longer offers an individual option. In 2026, Sourcegraph's pricing page is enterprise-only: contact sales, credit allocation, no self-serve tier. If your docstring strategy depended on Cody, it now depends on a sales call.

The Other Free Option Changed Too: Gemini Code Assist

For two years, Google's free tier was the "free beats everything" recommendation for individuals. Then, per Google's own banner notice, the Gemini CLI and Gemini Code Assist IDE extension for non-paying users were replaced by Antigravity on June 18, with users told to migrate or face feature disruptions. Paid Gemini Code Assist Standard is $22.80/month (monthly) or $19/month (annual commitment); Enterprise is $54 or $45. The lesson: a free tier owned by a company that will reshape its entire developer stack overnight is a free tier whose expiration date you don't control.

Comparison Table

Tool	How It Works	Price	Output Quality	Best For
GitHub Copilot	Inline generation in VS Code/JetBrains, no repo-level scan	Free (2,000 completions/month); Pro $10/month	Very good on typed code; mediocre on dynamic legacy code	Documenting as you write — the best free option in the test
Claude Code	Agent-style whole-directory batch documentation; preserves existing docs	Included in Claude Pro $17–20/month; Max $100–200/month; or API per token	Excellent — Raises clauses, runnable examples, real business context	One-shot catch-up on large legacy repos
Devin (formerly Codeium/Windsurf)	Inline editing and Tab completion within an autonomous Agent platform	Free (light quota); Pro $20/month; Teams $80/month + $40/seat	Good, on par with Copilot for Python	Teams that already bought an Agent platform for other reasons
docstring-ai (open-source on PyPI)	Batch CLI: file/directory scanning, three styles, dry-run, CI-ready	Tool is free (MIT); you pay your own Anthropic API bill	Good and consistent; strict about style	CI pipelines and scripted catch-up with zero seat cost
Gemini Code Assist → Antigravity	IDE completion and chat; free tier replaced by Antigravity	Standard $19–22.80/month	Good; historically generous free quota	Google-stack teams already on GCP
Offline single-file CLI (author's own)	Offline-first: scan, generate --apply, CI coverage gate, README export	$49 one-time	Structured and consistent; optional LLM mode	Enforcing documentation coverage in CI without a subscription

Who These Tools Are Not For

• People who need a public documentation site. None of these tools publish hostable, browsable API docs — that's Mintlify, ReadMe, or Swimm territory. Docstrings are raw material, not a website.
• Highly dynamic codebases. On code that leans heavily on decorators, metaclasses, getattr tricks, or ORM magic, every AI tool tested produced confident, plausible, and wrong descriptions. If the words can't be trusted, docstrings are just decoration.
• People who want docs to stay in sync. Copilot, Devin, and Gemini all document a single point in time and never look again. Only a CI coverage gate (or a code-coupled tool like Swimm) can catch drift, and a percentage gate only tells you docs exist, not that they're true.
• Teams using the tool as a substitute for review. AI docstrings still need a human skim. On messy legacy code, roughly one in every 50 generated docstrings is factually wrong — a small number, but it accumulates into confidently wrong documentation.

What are documentation drift and coverage gates? Documentation drift means code evolves but docstrings aren't updated in sync, so the documentation describes something other than actual behavior. AI generation tools are especially prone to drift because they only read the code at the moment they're invoked; afterward they neither monitor changes nor proactively invalidate stale docs. A coverage gate is a CI mechanism: it counts the share of functions with docstrings and fails the build if it's below a threshold, such as check --fail-below 80 in the article. It enforces the dimension of "does documentation exist" but cannot verify whether the documentation is correct — a function could sit at 80% coverage while half its docstrings lie. To fight drift, you need tools that couple documentation to code (like Swimm) or human review. So in practice they're usually combined: gates prevent omissions, spot checks prevent errors. Understanding this is what gives weight to the article's line that "a percentage gate only tells you docs exist, not that they're true."

The Honest Conclusion

If you document as you write, Copilot's free tier genuinely beats most paid options — the author didn't expect to say that in 2026 either. Two thousand completions a month covers most indie developers, and on the test modules the $0 tier's output was indistinguishable from the $10 tier's.

If you're catching up on a legacy repo, Claude Pro is the best value (assuming you already pay for it) — an afternoon of Agent time plus a few dollars of API usage yields hundreds of docstrings. If you refuse to subscribe per seat, the batch CLI is the honest answer: open-source docstring-ai costs nothing beyond API tokens, and the one-time $49 tool is the only option here that behaves like a product rather than a billing sheet.

If someone on your team is still proposing a docstring-only startup: first check whether its website loads. The category lost to general-purpose assistants, and the survivors are exactly those assistants.

An uncomfortable summary: in 2026, almost nobody should pay specifically for docstring generation. Pay for the assistant you'd use anyway and let it document along the way, or pay once for enforcement in CI. Everything else is renting a hammer.

One-line Summary

2026 AI docstring tool showdown: free Copilot is enough, dedicated startups are dead.

Paragraph Summary

Based on hands-on tests with a 60-module Flask API, a well-typed FastAPI service, and a small CLI tool, this article reviews the mainstream AI docstring generators of 2026. The core conclusions: GitHub Copilot's free tier (2,000 completions/month) produces output indistinguishable from paid tiers on typed code, making it the best free choice for indie developers documenting as they write; Claude Code is the highest-quality solution for batch catch-up on legacy repos, but as an autonomous Agent it will fix unrequested code along the way; docstring-focused startups (docstring.io, PyDoc AI, Stenography) have almost all died, and Sourcegraph Cody has dropped its individual tier. The author advises against paying specifically for docstring generation — instead pay for the assistant you already use, or use a one-time $49 offline CLI to enforce coverage in CI.