Athens

Cursor for Writing: What It Means and Why Writers Need It

- Moritz Wallawitsch

Developers have had Cursor since 2023. An AI code editor that reads your entire project, suggests changes inline, and lets you accept or reject each one. It changed how millions of developers write code. Not by replacing them. By working alongside them in the same editor, on the same files, with full context.

Writers have nothing like this. The state of AI writing in 2026 is still: open ChatGPT in one tab, your document in another, copy text back and forth, and hope you can spot what the AI changed. It is the equivalent of emailing code snippets to an AI and pasting the response back into your terminal. Developers would never accept that workflow. Writers shouldn't either.

The phrase "Cursor for writing" keeps showing up. People search for it. Writers blog about it. One developer literally uses Cursor IDE for prose because nothing better exists for writers. The demand is real. Let's talk about what it actually means.

What Cursor Gets Right for Code

To understand what "Cursor for writing" means, you need to understand what Cursor gets right for code. It is not just "an editor with AI." Lots of tools have AI bolted on. Cursor is different because the AI is integrated into the core editing experience.

Here is what that looks like in practice:

  • Full-project context. The AI reads your entire codebase, not just the file you're editing. It understands how functions connect, what naming conventions you use, and what patterns your project follows.
  • Inline diffs. When the AI suggests a change, you see it right in your editor. Red for deletions, green for additions. No switching tabs, no squinting at two versions side by side.
  • Accept/reject per change. You can take the changes you like and discard the rest. The AI proposes. You decide.
  • @-references. You can point the AI at specific files, documentation, or context with @-mentions. "Refactor this function to match the pattern in @utils.ts."
  • Tab completion. The AI predicts what you are about to type and offers it inline. Accept with Tab, ignore by keeping typing. Zero friction.

The key insight is that the AI never takes control. You are always in the driver's seat. The AI is a copilot that makes suggestions, and you have granular control over which suggestions to accept. This is why developers trust it. Not because the AI is perfect, but because they can see exactly what it is doing and override it instantly.

Why Writers Need the Same Thing

Writing and coding are more similar than people think. Both involve working with structured text. Both benefit from an assistant that understands context. Both require the human to maintain creative control while leveraging automation for tedious tasks.

In July 2025, Teju Adeyinka published a Medium article titled "Who's building the Cursor for writing?" that laid out the parallel clearly. She mapped the software development workflow onto the writing workflow: skeleton code is like an essay outline. Libraries and imports are like research and citations. The IDE is like a text editor. The developer-reviewer relationship is like the writer-editor relationship. The shipped product is the published essay.

Her conclusion: writers need an "Integrated Publishing Environment" - an IPE. A workspace that bundles research, drafting, editing, version control, and distribution into one tool. The same way an IDE bundles coding, debugging, testing, and deployment.

This framing is exactly right. And it explains why the current landscape of AI writing tools feels so incomplete.

The Copy-Paste Problem

Here is how most writers use AI today. They write a draft in Google Docs or Notion. They select a paragraph, copy it, switch to ChatGPT, paste it in with instructions like "make this more concise." ChatGPT returns a rewrite. They read it, try to figure out what changed, copy the parts they like, switch back to their document, paste, fix the formatting, and move on.

This workflow has at least five problems:

  • No document context. ChatGPT only sees the paragraph you pasted. It does not know what comes before or after. It cannot maintain consistent tone, terminology, or argument structure across your full document.
  • No change visibility. You get a wall of text back. What exactly did the AI change? You have to diff it manually in your head, line by line.
  • All-or-nothing edits. If the AI improved your opening sentence but ruined your closing one, you have to manually merge the good parts with the original. There is no way to accept some changes and reject others.
  • Formatting loss. Copy-paste between apps strips bold, italics, headers, and list structure. You spend as much time reformatting as editing.
  • Context decay. After 30 to 50 messages, ChatGPT starts forgetting earlier context. Long editing sessions degrade in quality.

Developers had this exact same problem before Cursor. They would copy code into ChatGPT, ask for a refactor, paste it back, and fix the broken imports. Then Cursor came along and said: what if the AI just edited your code directly, in your editor, and you reviewed each change?

Writers need the same leap.

Someone Literally Uses Cursor for Prose

Clark Dever, a writer and developer, published a post called "Why I Write With Cursor" explaining why he uses the AI code editor for all his writing. His reasoning is telling.

He values Cursor's context management. He can attach style guides, past blog posts, and interview transcripts as context with @-mentions. The AI sees everything at once and maintains a consistent voice across his project. Google Docs isolates each document. Cursor connects them.

He values inline diffs. Red deletions, green additions. He can see exactly what the AI changed and approve each edit individually. Google Docs has Track Changes, but it was never designed for AI-generated suggestions at this volume and speed.

He values git integration. Every version of his writing is tracked. He can branch, experiment, revert. As he puts it: "Great authors are great editors. First drafts are brain dumps. Final prose is what you sift from the rubble."

The fact that a writer is using a code editor for prose tells you everything about the gap in the market. The features writers need already exist. They are just trapped in tools built for developers.

What "Cursor for Writing" Actually Looks Like

So what does a proper "Cursor for writing" need? Based on what works for developers, what writers are asking for, and what the current tools are missing, here are the five essential features.

1. The AI Reads Your Full Document

Not a pasted snippet. Not a single paragraph. The AI sees your entire document - the introduction, the argument structure, the conclusion, the footnotes. When it suggests an edit to paragraph three, it knows what paragraphs one and two say. It maintains consistency in tone, terminology, and logic.

This is the equivalent of Cursor's codebase-wide context. A developer would never accept an AI that only sees one function at a time. Writers should not accept an AI that only sees one paragraph.

2. Edits Appear as Inline Diffs

When the AI suggests a change, you see it right in your document. Red strikethrough for deletions. Green highlight for additions. Not a chat response you have to mentally diff against your original. Not a separate "AI suggestions" panel. The changes appear exactly where they would take effect.

We wrote about this in detail in our post on inline suggestions vs. chat rewrites. The short version: inline diffs give you transparency. You see what the AI is doing at a granular level. Chat rewrites give you a black box.

3. Accept or Reject Each Change Individually

This is the feature that separates a real editing tool from a chatbot. When the AI suggests five changes, you can take three, reject one, and modify one. You are not forced into all-or-nothing. Every edit goes through you.

This is how writers maintain their voice. The biggest complaint about AI writing is that it makes everything sound the same. Accept/reject controls fix this. You keep the AI's structural improvements while preserving your word choices, rhythms, and quirks.

4. Markdown Under the Hood

Every major AI model thinks in markdown. GPT, Claude, Gemini, Llama. They were trained on billions of markdown documents. When you ask an AI to write, it outputs markdown. When you ask it to edit, it processes markdown.

This matters because markdown is the AI-native document format. A writing tool that stores documents as markdown can hand them directly to the AI with zero conversion. The AI reads the same text you see (rendered as rich text in the editor). It produces edits as simple text replacements. No block IDs, no proprietary JSON, no lossy format translation.

This is exactly why Cursor works so well for code. Code is plain text. The AI reads it directly, diffs it directly, and the editor renders those diffs inline. Markdown gives writers the same advantage.

5. Version History Like Git Commits

Developers have git. Every change is tracked. Every version is recoverable. You can branch off, try a wild experiment, and revert if it does not work. You can see exactly what changed between any two versions.

Writers need this. When you are iterating on a piece with AI help, you might go through twenty versions of a paragraph. You need to be able to go back to version twelve. You need to see what you changed between drafts. You need the confidence to experiment, knowing you can always undo.

This is not just "undo" in your editor. It is a full history of every meaningful revision, with the ability to compare any two versions side by side.

Why Existing Tools Fall Short

The market is full of "AI writing tools." None of them deliver the full Cursor experience for writers. Here is why.

Google Docs + Gemini. Gemini is integrated into Docs, which is a start. But the integration is shallow. It can help draft content, but it does not show you diffs of what it changed. It does not read your full document for context. The AI feels bolted on because it is. As Adeyinka noted, the current experience still involves "massive tab-switching pain."

Notion AI. Notion has an AI sidebar that can summarize, rewrite, and generate. But it operates on blocks, not on your full document. It cannot show inline diffs. There is no accept/reject workflow. And Notion's block-based storage format is opaque to AI models, requiring lossy conversion at every step.

Grammarly. Grammarly does show inline suggestions, which is closer to the Cursor model. But it is focused on grammar and style rules, not on substantive editing. It cannot restructure your argument, tighten a wordy paragraph by 40%, or suggest a better opening. It is a linter, not a copilot.

ChatGPT / Claude / Gemini (standalone). The best AI models available, but trapped in chat interfaces. The quality of the AI is excellent. The workflow is broken. You are still copy-pasting, still losing formatting, still diffing changes in your head. As we explored in our post on whether AI makes you a worse writer, the real risk is not the AI itself but the lazy workflow around it.

The IPE Vision

Adeyinka's IPE concept points to where this is heading. Just as developers moved from basic text editors to fully integrated development environments, writers will move from basic word processors to integrated publishing environments.

An IPE bundles everything a writer needs:

  • Research. Pull in sources, organize references, attach context the AI can use.
  • Drafting. Write in a clean editor with AI assistance that reads your full document.
  • Editing. Review AI suggestions as inline diffs. Accept, reject, or modify each one.
  • Version control. Track every revision. Compare drafts. Branch and experiment safely.
  • Publishing. Export or distribute your finished work without leaving the tool.

This is not a fantasy. Every piece of this technology exists today. Cursor proved it works for code. The question is who builds it for writing.

This Is What We Are Building

Athens is our answer to "who's building the Cursor for writing?" It is a markdown WYSIWYG editor where AI edits appear as inline diffs. The AI reads your full document. You see exactly what it changed. You accept or reject each edit with one click.

We are not building another chatbot with a text field attached. We are building the tool that writers like Clark Dever are hacking together with Cursor and git, but designed from the ground up for prose instead of code.

The features that transformed coding - full-project context, inline diffs, granular accept/reject, version history - are exactly what writing needs. Developers got their AI editor in 2023. It is time writers got theirs.