DEV Community: yanlong wang

A Free, Code-Aware Grammarly Alternative (No Signup, DeepSeek-Powered)

yanlong wang — Mon, 21 Sep 2026 23:47:52 +0000

Grammarly is good at prose. It is also $12-30/mo, and it still rewrites useEffect into "use effect" if you paste a component next to your sentences. If your writing lives in a repo, you need a checker that knows the difference.

Side-by-Side

Capability	Grammarly (Free/Premium)	Code-aware checker
Price	Free / $12-30 mo	Free (10/day, no signup)
Code-aware parsing	No	Yes
Identifiers preserved	No (often "fixed")	Yes (untouchable)
Backend	Proprietary	DeepSeek (BYOK free)
Signup	Required for most features	None

When the Free Alternative Wins

You write docstrings, READMEs, or comments and paste them whole.
You want zero account friction - open the tool, paste, done.
You want to self-host or bring your own key (BYOK mode is free entirely).

When Grammarly Still Wins

Long-form creative prose, team style guides, browser-everywhere integration. For repository-adjacent writing, the code-aware checker is the better fit.

Try It

No account, no card: free code-aware grammar checker. Pair it with the translator (code blocks skipped in translation too) and the readability analyzer for a full, free docs toolkit.

The whole thing runs on DeepSeek with a BYOK switch - so if you already pay for an API key, the checker costs you nothing beyond your own usage.

DeepSeek vs GPT-4 for Developer Writing Tools: A Cost, Latency, and Output Teardown

yanlong wang — Mon, 21 Sep 2026 23:47:14 +0000

If you are building a writing tool for developers, the model choice is the largest line item on your P&L. We benchmarked DeepSeek against GPT-4 on the three tasks our users actually run, with 200 samples each.

Task 1: Rewriting a Docstring (keep identifiers intact)

Model	Identifiers preserved	Style score (1-5)	Median latency
DeepSeek	100%	4.3	0.9s
GPT-4	100%	4.5	1.8s

Both preserved identifiers (our pipeline forces it). Style difference was within reviewer noise.

Task 2: Polishing a README Section

Model	Readability gain	Median latency
DeepSeek	+18%	1.1s
GPT-4	+21%	2.0s

Task 3: Drafting API Error Copy

Both produced clear, non-leaky error messages. DeepSeek's tone was slightly more terse; GPT-4 a touch more verbose. Either is shippable.

The Bill

For our traffic profile (mostly short edits), DeepSeek came in around 1/10th the cost of a GPT-4-class endpoint at comparable quality. On interactive tools, that difference is the difference between "free tier is sustainable" and "free tier loses money on every user."

What This Means for You

If your tool edits developer text, prototype on DeepSeek, keep GPT-4 as a paid "pro" tier, and gate the choice behind a BYOK switch so power users can bring their own key. That is exactly the model our grammar checker and paraphraser use: DeepSeek by default, BYOK for self-hosting.

Bottom line: for developer writing tasks, GPT-4's edge is real but small, and the cost curve makes DeepSeek the default for anything interactive and free.

How We Built a Code-Aware Grammar Checker on DeepSeek (and Why It Matters for Devs)

yanlong wang — Mon, 21 Sep 2026 23:47:07 +0000

Every developer has felt this: you paste a README paragraph into a grammar checker, and it "corrects" maxRetries into "maximum retries", or flags kubectl get pods as a fragmented sentence. The checker doesn't know code from prose, so it edits the one thing you can't change.

The Core Problem: Code Is Not Prose

Grammar models are trained on books and articles. To them, a line like cache_size = config.limit ?? 512 is just a very weird sentence with weird words. They will "improve" it - and break your code. The fix is not a better model; it is a better pipeline.

Architecture: Parse First, Reason Second

Stage	What happens
1. Split	Markdown/HTML is split into prose spans and code spans (fenced blocks, inline `code`, identifiers).
2. Protect	Code spans are marked untouchable. Identifiers, commands, flags are never rewritten.
3. Reason	Only prose spans go to the language model for grammar/style suggestions.
4. Merge	Suggestions re-injected next to original code, zero mutation of identifiers.

The result: your cache_size comes back as cache_size, and your real English mistakes still get caught.

Why DeepSeek Powers the Reasoning Layer

For this job the model has to do one thing well: edit short prose while respecting "don't touch the code". We evaluated the usual suspects and landed on DeepSeek for three practical reasons:

Cost: at our volume, a GPT-4-class endpoint would be ~10x the bill for no measurable quality gain on grammar/style edits.
Latency: grammar checks are interactive - users expect sub-second feedback. DeepSeek's smaller variants hold up.
Instruction following: the "leave code alone" constraint is a system-prompt discipline the model follows reliably.

Try It

The checker is live and free (10 checks/day, no signup): code-aware grammar checker. If you write docstrings or READMEs, also try the paraphraser - same code-aware protection, so your identifiers survive the rewrite.

We open-sourced the parsing approach; the lesson that matters most is that the model choice is secondary to the pipeline. Get the split-and-protect stage right, and almost any modern model will do.

Western Astrology Apps vs Qimen Dunjia: 2026 Pricing, Strengths & a Real Reading

yanlong wang — Wed, 16 Sep 2026 02:53:19 +0000

Originally published on the Qimen AI blog — prices checked 2026-09-16, no paid rankings.

Disclosure: this article is written by the Qimen AI team — which is both a strength (we know Qimen Dunjia chart mechanics deeply) and a conflict of interest (one system below is ours). So we stick to factual comparison: published pricing, how each system works, and what each is genuinely good at. One real reading from our product is included as a worked example, with its machine-audited score.

Two different questions

Western astrology, as the big apps deliver it, is fundamentally a birth-chart system: it reads where the planets sat when you were born and builds personality insight, compatibility and daily forecasts from that. It answers: "Who am I, and what's the weather like for people like me?"

Qimen Dunjia (奇门遁甲) is a question-and-moment system from the Chinese strategic arts — historically used for timing military and business decisions. You ask a specific question at a specific moment, a chart is cast for that moment, and the reading returns structured guidance: where the leverage is, when the window opens, which direction to move. It answers: "Given this decision, here and now, what does the field look like?"

Neither replaces the other. One is a mirror; the other is a map of the current terrain.

What it costs in 2026 (real numbers)

System	Free tier	Paid	Input needed
Co-Star	Daily reading, free	Pro-Star $8.99/mo; reports $4.99–$11.99	Birth time to the minute
The Pattern	Yes, limited	$14.99/mo or $83.99/yr	Birth date; effectively exact time
Sanctuary	Free daily	$14.99/mo or $49.99/yr; live readings $4.99–$50	Full chart for depth
CHANI	Free daily	$11.99/mo or $107.99/yr	Exact birth time
Nebula	Limited	From $7.99/wk; ~$49.99/yr	Birth chart data
ZODIA	7-day trial	$14.99/mo (WhatsApp daily)	Exact birth chart
Astrogya GYAN	—	$44/mo flat	Birth chart
Qimen AI (this site)	5 full readings/month, free	Beta: $1.50 one-time (30 days) · $4.50/mo · $14.50/yr	Just the question — no birth time

The honest read on price: mainstream Western astrology subscriptions cluster around $9–15/month or $50–108/year. Qimen AI's beta pricing sits at roughly 1/3 to 1/7 of market rates — deliberate cold-start pricing, not a claim that our system is worth less. If you've ever been quoted $4.99/minute for a psychic reading, flat models look refreshing either way.

Strengths and weaknesses, side by side

	Western astrology apps	Qimen Dunjia (Qimen AI)
Best at	Self-understanding, identity, relationships, a daily ritual	A specific decision: pivot or persist, when to act, where the opening is
Input	Exact birth time to the minute — which many people don't know	Just your question and the moment you ask it
Output	Personality profiles, daily horoscopes, compatibility	Structured reading: situation, leverage, timing window, direction, one action for today
Verifiability	Subjective by design; no per-reading quality scores	Every reading machine-scored by a rule-based evaluator; charts reproducible from classical rules
Learning curve	Gentle — sign vocabulary is pop culture	Steeper — stems, stars, doors, gods (every term footnoted in our readings)
Weak spots	Vague daily copy; subscription creep; AI-written-text complaints on big apps	Smaller community; unfamiliar symbolism; no dopamine daily horoscope

The deepest structural difference: astrology tells you who you are and expects you to derive decisions from that. Qimen takes the decision itself as input and returns terrain, timing and direction. If you already know yourself and are stuck on "should I actually do X this month?", the second is the question natal charts were never designed to answer.

A real reading, scored

Talk is cheap. Here is an actual Qimen AI case (one of 20 real-chart cases in our library), condensed.

Objective score: 8 / 10 — scored by a rule-based evaluator, not self-graded.

The question: "Solo founder stuck at 18 months — should I keep going or pivot? Revenue is flat." Asked 2026-09-01, 14:00.

Chart signature: Yin Dun · 4th Bureau · full fu-yin loop (the classical "stagnation" pattern) · Horse Star in Qian 6 · Void at Zi–Chou.

What the chart said:

Diagnosis. The founder's stem (Wu) sits in Xun 4, clipped by the Wood palace, riding Tian Peng (hidden risk) + Jing Men (surface heat): "revenue isn't flat because of the market — it's flat because you've been 'showing' instead of 'rooting'." A fu-yin loop is not a dead end; it's a grinding loop — polish, don't blindly expand.
The opening. Kai Men (the Open Door — career path) falls in Dui 7 with Tian Fu (learning) + Liu He (partnership): the way out is deepened expertise plus borrowed strength, not more solo pushing.
Timing. The Horse Star activates around early winter (post-Lidong): that is the window to re-evaluate "persist or pivot" — not today, and not by forcing it now. Direction to seek partners: West.
One action for today. Cut the single lowest-yield, most time-draining task, and use the reclaimed hour to package your best 18-month case study for a potential partner. The reading explicitly refuses to decide for the founder: "the chart hasn't sentenced you — it says pushing harder inside a fu-yin loop is a counter-force; dismantling the wall is the move."

Why it scored 8/10: every Qimen AI reading is audited by objectiveEvaluate, a rule-based evaluator separate from the reading model. It checks correct bureau construction, use-spirit placement, the full six-harm checklist (this chart correctly reports punishments, tombs and door-forc as absent), and whether timing/direction/action actually follow from the chart. You can verify the chart yourself: cast 2026-09-01 14:00 in the free tool and the palaces match, line for line.

So which one should you use?

Western astrology apps — when you want to understand yourself, your patterns and your people, and enjoy a daily ritual.
Qimen Dunjia — when a real decision is on the table this month and you want structured timing, direction and a next action, without a per-minute meter running.
Both — The Pattern tells you why you hesitate; Qimen tells you what the terrain looks like if you go.

FAQ

Do I need my birth time for Qimen Dunjia? No — the chart is cast for the moment you ask. That's also why it works for people with no idea what time they were born.

Is Qimen Dunjia astrology? Not in the Western sense. It belongs to the Chinese strategic arts (三式) and uses time–space palaces rather than planets — structurally closer to a decision-support system built on classical symbolism.

Aren't these readings just vague statements that fit anyone? The Forer effect is the classic risk in all divination. Our countermeasures are structural: reproducible charts from classical rules, an independent rule-based quality score, and readings that must reference specific palace placements you can check yourself.

Try it free — 5 full Qimen readings a month, no birth time needed, no card required: qimenai.aicreditsapi.com

Qimen readings are offered as a cultural and self-reflection tool. They do not constitute financial, medical, legal or psychological advice.

Qimen vs Tarot vs Astrology: three different questions, and the mistake everyone makes

yanlong wang — Wed, 16 Sep 2026 02:23:01 +0000

Every few months someone on my feed rediscovers astrology, tarot, or some oracle app, uses it for a week, gets a vague reading, and declares it all useless.

Almost every time, the actual problem is a category error: they asked a situational question and used a personality tool.

The three tools answer three different questions

Astrology answers: "What is my baseline wiring?" It's a birth-chart system — your natal snapshot. Asking it "should I send this email today?" is like asking your DNA for calendar advice.

Tarot answers: "What am I not seeing in myself right now?" It's a mirror. Brilliant for inner states, blind spots, emotional framing. But the reading changes with the reader as much as the cards.

Qimen Dunjia (奇门遁甲) answers: "What is the structure of THIS situation, right now?" It was built as a military decision framework: encode time, direction, and context into a chart, then read the tactical picture. Same question asked an hour later produces a different chart — because the situation genuinely changed.

The mistake

Using tarot to decide whether to launch on Tuesday. Using astrology to evaluate a specific negotiation. Using qimen for self-identity. All three feel "inaccurate" because you're holding the wrong instrument.

A quick routing table:

Your question	Better tool
Why do I keep doing this pattern?	Astrology / therapy
What am I feeling but not admitting?	Tarot / journaling
Should I act now, wait, or walk away — on this?	Qimen-style situational analysis

The common core — and the honest version

All three systems work (to the extent they do) through the same mechanism: externalized structure forces slow thinking. A chart you didn't fully control breaks your loop of rumination and makes you consider angles you'd have skipped.

That's also why I'm suspicious of any of them claiming literal prediction. My own take, building a qimen tool: it's a decision-support mirror, not a crystal ball. It shows you the structure of the moment — pressure points, timing, which way the door swings. It doesn't know your future, and anyone selling you certainty is selling markup on your anxiety.

If you're curious what a situational reading feels like (vs. your Co-Star feed), JingMing Qimen does the full chart free — no account needed. Ask a real question, get the eight-door breakdown, judge for yourself.

Which tool have you been using — and was it actually the question you had?

Paraphrasing Code Comments: QuillBot, Wordtune, and a Code-Aware Option Compared

yanlong wang — Wed, 16 Sep 2026 01:57:30 +0000

Paraphrasing regular prose is a solved problem. Paraphrasing text that contains code - a docstring, a README paragraph, a comment above a tricky function - is not, because a paraphraser that does not know what code is will "improve" your identifiers into prose. This post compares the three common approaches on that specific job.

Option 1: QuillBot

The market leader: 9 modes, free tier capped at 125 words per rewrite, Premium $8.33/mo (annual). On prose, strong. On a docstring, the free tier forces you to cut the code out first, and even then inline references like config.maxRetries may get reworded into "the maximum retries configuration". You paste back and re-verify by hand.

Option 2: Wordtune

Wordtune ($6.99-9.99/mo, 10 free rewrites/day) rewrites sentence-by-sentence, which fits comments well - you select one sentence, not the whole file. Code handling is still prose-first: select a line containing a command and it will offer rewrites that no longer parse.

Option 3: A Code-Aware Paraphraser

The third approach parses the input before rewriting: code spans, identifiers, and commands are marked untouchable; only the prose around them is rephrased. Lint's paraphraser works this way - paste a docstring whole, get a rephrase where cache_size is still cache_size. Free tier: 10 uses a day, no signup; BYOK mode free entirely with your own API key.

Which Fits Which Job

Pure prose (blog posts, emails): any of the three; pick by price and interface
Comments and docstrings: code-aware parsing saves the paste-out/paste-back cycle and the re-verification
Long docs mixing both: code-aware, or split the document manually first

Try Lint's paraphraser on one of your own docstrings - free, no account, and your identifiers come back the same way they left.

Readability Scores for Technical Documentation: Flesch, Hemingway, and Code-Aware Tools

yanlong wang — Wed, 16 Sep 2026 01:56:38 +0000

Readability scores - Flesch Reading Ease, Flesch-Kincaid Grade, Gunning Fog - were built on prose. Technical documentation breaks their assumptions: a line of code counts as a "sentence", identifiers count as "syllables", and your README's grade level quietly becomes nonsense. Here is how the main options compare.

The Tools

Tool	What it gives you	Code handling
Word / Google Docs built-ins	Flesch-Kincaid grade	None - code counts as text
Hemingway Editor	Grade level + visual density	None - paste code and the grade tanks
Hemingway Editor Plus	~$10/mo, AI rewrites	None
Online Flesch calculators	Raw score	None
Lint readability analyzer	Flesch family scores	Code lines excluded from the math

Why Excluding Code Matters

A README that is 60% prose and 40% code will score as "very difficult" on any prose-based tool - not because the writing is bad, but because kubectl get pods -o jsonpath=... reads as an unreadable sentence. The practical failure: writers then "simplify" good documentation to please a number.

A code-aware analyzer splits the document first. Prose gets scored; code blocks, commands, and inline identifiers are skipped. The resulting number describes the thing you can actually edit - your sentences.

How to Use Scores Without Obsessing

Target range, not a number: for developer docs, Flesch Reading Ease 40-60 ("difficult" to "plain English") is normal and fine
Watch the trend: a jump from 52 to 30 after adding a section is a signal; the absolute number is not
Sentence length beats syllable counting: for technical audiences, long sentences are the real killer - fix those first

Try Lint's readability analyzer - deterministic formulas, code excluded, free tier, no signup. Pair it with the grammar checker on the same text.

LanguageTool Free vs Premium: A 2026 Breakdown for Technical Writers

yanlong wang — Wed, 16 Sep 2026 01:55:46 +0000

LanguageTool is the go-to open-source grammar checker, with a free tier many developers use daily. Premium runs $4.17/mo on the two-year plan (up to ~$9 monthly). Here is what the upgrade actually changes, evaluated specifically for technical writing.

Free vs Premium, Line by Line

Capability	Free	Premium
Basic grammar/spelling rules	Yes	Yes
Character limit per check	2,000	Unlimited
Style and tone suggestions	Limited	Full
AI paraphrases	3/day	More
Self-hosted server	Yes (core)	Yes
Code-aware checking	No	No

The last row matters most for developers: Premium buys volume and style depth, but the engine stays prose-first on every tier. Pseudo-code in comments, camelCase identifiers, CLI flags still trip the rules the same way.

Who Should Upgrade

Upgrade if you write long documents (the 2,000-character cap is the sharpest free-tier edge) or want the style layer. Stay free if your checks are short snippets and you value self-hosting - it is the only major checker that offers it.

The Alternative Angle: Code-Aware Checking

If most of your writing lives next to code, the tier decision matters less than the engine decision. A code-aware checker such as Lint skips identifiers, commands, and fenced blocks on every tier - including the free one (10 checks/day, no signup). A reasonable setup: LanguageTool self-hosted for prose documents, Lint for anything that lives in a repository.

Try Lint free - and compare the false-positive rate on your own README.

Grammarly Free vs Premium: What Developers Actually Get (2026)

yanlong wang — Wed, 16 Sep 2026 01:54:53 +0000

Grammarly's free tier is the most-used grammar checker on earth, and Premium is $12/mo billed annually ($30 month-to-month). Most comparisons of the two tiers cover essays and business mail. This one covers the text developers actually write - and where both tiers behave the same way.

What Free Actually Includes (2026)

Basic grammar, spelling, punctuation - unlimited words
100 AI prompts per month
Browser extension, web editor, desktop app

What Premium Adds

Full-sentence rewrites, clarity and tone suggestions
Plagiarism detection and AI detection
2,000 AI prompts per month, 7-day trial

The Part Every Comparison Skips: Code

On both tiers, Grammarly's engine treats your document as prose:

Input	Grammarly Free	Grammarly Pro
`userId` in a sentence	Often flagged	Often flagged
`npm run build --watch`	Flagged as fragment	Flagged as fragment
Fenced code blocks	Scanned by extensions	Scanned by extensions
Plagiarism / AI detection	Locked	Unlocked

Premium unlocks features; neither tier has a model of what code is. Upgrading fixes your word count and unlocks detection - it does not stop false positives on identifiers.

The Decision Rule

Prose all day? Free is genuinely usable; Premium pays off when you want tone control and detection. Documents that mix code and prose - READMEs, PR descriptions, docs? A code-aware checker such as Lint skips code by design on its free tier (10 checks a day, no signup), which is the gap neither Grammarly tier covers. BYOK mode is free entirely if you have an API key.

Try Lint's grammar checker - and keep your userIds untouched.

Grammar Checking Markdown Without Breaking Code Blocks: What Actually Works

yanlong wang — Wed, 16 Sep 2026 01:53:36 +0000

Markdown is the default format for developer writing: READMEs, CHANGELOGs, docs sites, blog posts. It is also the format most grammar checkers handle worst - because Markdown is prose interleaved with syntax and code, and general-purpose checkers treat all of it as one text stream.

What Goes Wrong

Markdown element	What a prose checker does	What should happen
Fenced block


 | Checked as sentences; identifiers flagged | Skipped entirely |
| Inline `code` | Backticks and casing flagged | Preserved as literal |
| Link syntax `[text](url)` | URL treated as a word soup | Only the link text checked |
| Table rows | Read as fragments, flagged | Cell text checked, pipes ignored |
| Front matter | YAML keys "corrected" | Skipped entirely |

The worst outcome is not false positives - it is a checker that *auto-corrects* and rewrites a URL or changes `None` to `none`, breaking the document while claiming to fix it.

## What a Markdown-Safe Checker Must Do

1. **Parse before checking:** split the document into prose regions and code/syntax regions, and only check the prose
2. **Preserve spans:** inline code, links, and emphasis markers must survive any edit byte-for-byte
3. **Show, then apply:** fixes should be reviewable one by one, never silently applied to the whole file

## Tools in This Space

LanguageTool integrations and Word's checker will process Markdown, but as plain text with the failure modes above. Linters like vale check style rules, not grammar, and need per-project configuration. [Lint's grammar checker](https://tools.aicreditsapi.com/tools/grammar-check) is built for exactly this input: fenced blocks, inline code, and commands are recognized and skipped by design, and suggestions never rewrite code spans. It runs in the browser - paste the Markdown, review flagged items, keep everything else untouched. The same engine powers its [readability analyzer](https://tools.aicreditsapi.com/tools/readability-analyzer), which excludes code lines from scoring.

[Try Lint on your README](https://tools.aicreditsapi.com/tools/grammar-check) - free 5 checks a day, no signup.

Google Docs Spell Check for Developer Docs: Free, Convenient, and Limited

yanlong wang — Wed, 16 Sep 2026 01:52:45 +0000

Google Docs is where a large share of technical collaboration starts: specs, drafts, internal docs, and blog posts all begin in a Doc. Its built-in spell check is free, automatic, and good at ordinary typos. Here is a neutral look at where that convenience stops when the document contains code.

What the Built-in Checker Covers

Ordinary spelling mistakes and obvious agreement errors
"Did you mean" suggestions as you type, no setup required
Personal dictionary additions, so product names stop being flagged

Where It Stops

Docs' checker is tuned for prose, and developer documents are rarely pure prose:

Identifiers and commands: useAuthState, docker compose up -d, and snake_case flags either get flagged or need to be added to the dictionary one by one
Code blocks: pasted code inside a Doc is checked like text unless you format it as code - and once you do, grammar checking stops inside it
Grammar depth: subtle issues like tense drift in docs or dangling modifiers get missed; the engine prioritizes obvious errors over depth

The Common Workflow Gap

The usual pattern: draft in Google Docs, then move the text to a repository, README, or blog. The Doc-stage check covers prose typos; everything code-adjacent is unchecked until a reviewer squints at it. A code-aware checker such as Lint runs in the browser on the final text - free tier of 5 checks a day, no signup - and skips code by design, closing that gap without changing your Doc workflow.

Bottom line: for a pure-prose internal memo, Google Docs is enough. For anything that will end up in a repo with code blocks in it, add one code-aware pass before merge.

Try Lint's grammar checker - built for text that contains code.

Using ChatGPT as a Grammar Checker: What Works and What Silently Breaks

yanlong wang — Wed, 16 Sep 2026 01:51:53 +0000

"Fix the grammar" pasted into ChatGPT is probably the most-used grammar checker on earth right now. It works surprisingly often - so it is worth being precise about where it works and where it quietly fails, especially for technical text.

What It Does Well

Availability: no new tool to learn; it is already open
Context tolerance: it understands intent, so awkward phrasing gets smoothed, not just flagged
Tone shifts: "make it professional" works in the same prompt

The Failure Modes

ChatGPT is a text generator, not a rules engine. Three consequences matter:

Silent rewrites: the model may rephrase meaning, drop a caveat, or flip a negation. A grammar pass should change grammar, not claims.
Code mangling: identifiers inside sentences get "fixed" - userId becomes "user ID", None gets recased, command flags edited. The model will confidently rewrite a variable name.
Non-determinism: the same text can get different corrections on different runs, which makes editing workflows hard to trust and review.

How Dedicated Tools Differ

A purpose-built checker separates finding errors from rewriting text: it flags issues with explanations and leaves your wording (and code) alone. Lint's grammar checker is built on that principle - code identifiers are recognized and skipped by design, and a fix never silently changes what your sentence claims. For machine-sounding text that needs a human voice without touching structure, the dedicated tool is Naturalize, which preserves code blocks while humanizing prose.

A Reasonable Division of Labor

ChatGPT: drafting and tone transformation, where rewriting is the point
Dedicated checker: the final grammar pass on anything with technical claims, identifiers, or commands - review should be able to trust "grammar-only" edits

Try Lint's grammar checker - deterministic, code-aware, free 5 checks a day.