LLM Writing Guide: Rules, Tools, and AI's Expanding Role

How to Write with an LLM: Two Rules for Keeping Your Voice

Using a large language model to help write can feel like a Faustian bargain. You gain speed and polish, but risk producing prose that reads like it was pasteurized and injected with corn syrup. As one tech blogger recently put it, readers can detect LLM words in the parts per trillion. The key, then, is to use these tools like a copyeditor, not a ghostwriter.

This approach is gaining traction among writers who want to leverage AI without sacrificing their unique style. The method is simple: write your piece first, then feed it to a good model to find flaws. But to avoid the uncanny valley of AI-generated text, two rules are essential.

Rule One: Never Use an LLM's Exact Words

The first rule is strict: you may not use a single word an LLM suggests. Frontier models are supernaturally good at selecting pleasing turns of phrase—it's their whole thing. But the problem is subtle: they're wedged in a mode where everything they write is a magazine headline. Headlines are good, but you'd wonder about someone who wrote an entire article with dozens of them.

This rule acts as intellectual personal protective equipment. Even if you like the words, even if you're sure they're better than what you have, LLM-generated phrases are disqualified. The premise is that you won't reliably spot all the ways models will try to turn your writing into Velveeta. So, be strict about it.

Rule Two: Avoid Encouragement

The second rule is subtler: avoid encouragement. Hand any piece of writing to an LLM, and it replies "that's gold, Jerry!" But that's not what you need to hear. In your first draft, most of your paragraphs are bad, your topic flow is incoherent, and you've got at least 750 words you don't need. The model encourages you about your overall structure, then later about paragraphs and transitions, then word choices and metaphors. They're all bad!

If you listen, you'll double down on first-draft impulses instead of editing, rethinking, and replacing paragraphs. Those rethinks are load-bearing parts of your voice. Readers won't put their fingers on what's wrong, but they'll sense you've become artificially flavored. So forbid the model from encouragement and be hypervigilant about praise.

What LLMs Are Actually Good At

Despite these caveats, LLMs are excellent at flagging problems. They don't get tired, so they're better than you at noticing overused passive voice, nominalized verbs, repeated turns of phrase, and filler words like "very" and "unfortunately." They can also spot 2-3 paragraphs that you can quickly move elsewhere to improve clarity—these are really, actually, very satisfying edits.

For a systematic approach, the book Style: Lessons in Clarity and Grace is often recommended. It turns copyediting into a mechanical process, much like Java coding. Read it, take notes, and come up with a list of prompts to run in passes over your work. Then, ask the model to spot problems, rewrite each problematic section, and present both versions to a model without context to judge which is better.

Some writers have even built custom tools to manage this process, using Python, HTMX, and SQLite to create a writing workshopping tool that supports highlighting and side-by-side comparisons. The goal is to outsource the tedious work while keeping your voice intact.

Beyond Writing: LLMs in Malware and Hardware Design

LLMs are also transforming other fields, sometimes with concerning implications. CrowdStrike recently uncovered PhantomRaven, a JavaScript information stealer written by a self-proclaimed bug bounty hunter who likely used an LLM. Clues include verbose comments, placeholder code, and statistical token parsing patterns characteristic of AI-generated text. This case highlights how AI is reducing the time and expertise required to create sophisticated malware.

On the hardware side, Lattice Semiconductor has launched Lattice Prompt, a free FPGA AI tool that covers the full design flow using validated device docs. Unlike general-purpose LLMs, it uses retrieval-augmented generation to pull from Lattice's datasheets and app notes, anchoring outputs in device-specific facts. It also orchestrates Lattice Radiant EDA software, producing complete design flow steps rather than just text.

Local LLMs and the Subscription Killer

For everyday users, local LLMs are becoming viable alternatives to subscription services. One writer found that Gemma 4, a small model running on a laptop, could replace Grammarly's $30/month subscription. Unlike Grammarly, which focuses on grammar, Gemma 4 acts like an editor, tightening writing and providing conversational variations with explanations. With tools like LMStudio or OpenWebUI, you can drop in documents and get answers just as expected.

This shift matters: you don't need an AI workstation to benefit. Smaller, more capable models are making local AI practical for saving money and maintaining privacy.

The Bigger Picture: Agents and Accountability

As LLMs evolve, they're powering "agents"—automated systems hooked up to tools that can affect the real world. An agent needs a goal, an LLM, tools like a web browser, memory, and a loop to review results. Agents can delegate to sub-agents, creating complex workflows. But this also amplifies risks: when an LLM powers an Ask → Act → Report loop, its plausible but unpredictable output becomes the sole driver of actions with access to powerful tools.

This is where the anti-social nature of these systems emerges. LLMs routinely produce "slop," inventing quotes, evidence, or data because it's plausible based on training weights. A lawyer might hallucinate an entire case, which is now routine. When hooked up to powerful tools, this becomes disastrous.

As AI's capabilities expand, so does the need for thoughtful guidelines—whether in writing, security, or hardware design. The two rules for writing with an LLM are a microcosm of a larger challenge: how to harness AI's power without losing our own.