This is the first post in a series about AI workspaces for comfortable, reproducible collaboration with AI. I explore alternatives to “ChatGPT-like” AI platforms that actively use past context. This context includes any artifacts created in AI chats, such as posts, reports, plans, requirements, and even fiction. Instructions for the AI are also part of that context and are often worth reusing for new tasks.

In this post, the artifacts are long-form posts/articles, and the alternative to ChatGPT/Gemini/Claude/Perplexity is a local AI workspace—specifically, Cursor and Trae IDE, which are similar to each other.

Cursor for long-form writing is not yet mainstream, and there’s little information online about HOW to do it. There are a few posts answering the “WHY,” for example:

• A post by someone already writing in Cursor

• A post by someone waiting for an AI IDE specialized for writers

Using an IDE for Writing: Why and When

IDE stands for Integrated Development Environment, and it has been the primary tool for software developers for decades. Thanks to AI, the IDE has become suitable for many tasks beyond coding.

It’s no secret that the software development field is often the first to try out the most advanced AI applications, especially when it comes to personal productivity. So, it’s worth being aware of AI approaches from this field, even if you don’t want to become a developer.

This is how I see Cursor’s scope of application beyond coding, within the broader picture of AI tools:

In other words, Cursor is excellent for regularly producing complex artifacts (e.g., lengthy texts) in your area of expertise.

Even if this post doesn’t convince you to try an IDE like Cursor for non-coding tasks right now, it’s worth knowing what an AI IDE is capable of.

1. My Path to Writing in an IDE

I’m not a professional software developer, though I’ve often participated in software projects as a systems/business analyst and project/product manager. Over the last year, I’ve used Trae IDE to build small apps in Python, a language that was new to me.

• As recently as six months ago, I was skeptical about solving a broader set of tasks in an AI IDE because it felt too unconventional for non-coding work.

• I also thought the venerable age of local IDEs was a drawback. The concept emerged more than 30 years ago—almost in step with the rise of the graphical user interface (GUI). I assumed IDEs were too software-specific and old-fashioned, and that it would be better to adopt entirely new UI/UX concepts in the age of AI.

I was wrong. This summer, I bought a $10 subscription to Trae.ai because I had outgrown Trae’s free limits for my occasional coding tasks. Then, I also tried using this IDE to improve the readability of my articles—something I previously did in Claude or ChatGPT using my system prompts, for example, this GPT. I tried it mostly so the Trae subscription wouldn’t go to waste, since I don’t write code every month.

It turned out that writing in an IDE is incredibly convenient for me—so much so that I changed my approach to writing. Now, I’m sharing what I’ve learned.

As for long-form posts, I don’t know how to achieve the same efficiency without an IDE. I could buy a specialized tool for bloggers and writers and follow its built-in workflow. I’ve researched such tools, and the best ones I found are Spiral and Jasper AI. However, I don’t earn money from writing to justify a $25–$69/month subscription. Moreover, buying different specialized tools for different task types is not cost-effective.

2. AI-Powered Writing: Example Workflow

Let’s look at a workflow for writing a long post (article) with an AI copilot. What work should be delegated to AI?

Github Copilot’s documentation recommends using the AI features of an IDE for brainstorming, outlining, drafting, and refining blog posts.

I believe a writer should invest their main cognitive effort in the creative parts of the work. That’s the only way to achieve high quality without spending a lot of time on the more technical parts.

As I have a large backlog of my own ideas, I don’t use AI for brainstorming. If I did, I would probably use ChatGPT for that, because brainstorming is the most creative and unstructured process and rarely fits into a predefined IDE workflow.

Here’s my default workflow:

1. Start with brain-dumping (no AI).

2. Generate an outline with AI, then rethink and improve it.

3. Draft section files with AI, using the brain dump and outline.

4. Review and expand sections that weren’t described clearly enough in the brain dump. I may expand some sections myself and others with AI.

5. Validate at a high level to ensure the article isn’t too long, contains only relevant ideas, and has a smooth flow. At this step, I often remove unimportant paragraphs (saving them for future posts) and rewrite the introduction and conclusion.

6. Refine and polish the text with AI, especially when the original brain dump is not in English, as the AI’s translation at Step 3 isn’t good enough. AI also enhances my English phrases added during Steps 4–5.

Below, I explain these steps in more detail for Trae IDE. The workflow itself can be the same for Cursor or VS Code with an AI plugin like OpenAI Codex or Claude Code. The rule files described below are largely compatible with Cursor.

Step 1. Brain-dumping

Create a new folder and a braindump.mkd file, then write or dictate your ideas freely.

• Dictation is easy with Wispr Flow: place the cursor in the file editor and speak holding the hotkey (Fn on Mac or Ctrl+Win on Windows).

• If you’re not a native English speaker, write or dictate in your language. The AI will later translate non-English parts into English.

• No rigid structure is required, but light Markdown formatting (e.g., bullets and headings) helps the AI produce meaningful sections in the next step.

• Unless prompted explicitly, the AI preserves the order of ideas from the dump, so consider restructuring it before proceeding.

• You may add <TBD> tags where extra paragraphs or sections are needed. My outline_rules.md will convert those tags into AI-generated content later.

Step 2. Creating an Outline

Generate outline.mkd using a prompt like Write an outline from #braindump.mkd or Write an outline #folder-name.

• Here, #braindump.mkd is a link to the file created at Step 1. It’s faster to add it by dragging and dropping the file into the prompt.

• If you use #folder-name instead of the file, the AI agent will find the braindump file within that folder.

Edit the generated outline carefully, as it defines the article’s structure.

• The outline file includes @ lines for future section file names (e.g., @0-intro).

• Alternatively, you may remove all @ lines except one; this option is discussed in the next step.

Step 3. Generating section files

This is where an IDE does a lot of technical work. With one prompt, it performs multiple file operations that can’t be done in chatbots like ChatGPT.

Prompt: Create sections #folder-name according to outline_rules and article_rules using samples: #another-folder-name.

• outline_rules.md clarifies how to interpret the prompt and covers technical details like file naming.

• article_rules.md sets content requirements, Markdown formatting, and how to use examples to mimic tone and style.

You can generate a single draft file instead of multiple section drafts. This way, you’ll have less to do at the final step when your polished post is copied to a social network or blogging platform. However, I don’t recommend this approach:

1. Posts longer than ~1000 words are hard for LLMs to process reliably, despite their larger context windows. Splitting the text into section files improves quality.

2. Typically, writers need multiple section files at Step 4, “Expanding.” It’s more convenient to keep several file tabs open, one of them being the current writing. Other tabs can be used for reference or to write down random thoughts that come to mind but don’t belong in the current section. If you go back and forth within one file, you easily lose writing focus.

Step 4. Expanding and Validating

At Step 3, my rules prohibit introducing new ideas beyond the initial braindump unless a <TBD> placeholder appears. Consequently, AI-generated sections are often shorter than a good article requires, making expansion necessary.

Prompts like Expand #file-name.md using samples: #another-file-name.md can help, but it’s better to specify exactly what needs expanding and what micro-ideas to add.

Even when a prompt is rich with your ideas, the quality of AI output can be unpredictable. The expanded version might be superficial and miss the original meaning. Therefore, it’s wise to save the shorter version to Git before expanding with AI; the next section covers how to do this.

In many cases, I expand manually because it can be more difficult to set the task for the AI and then validate its mediocre output.

This is similar to a common problem for AI coders: it’s often faster to write the code yourself than to craft a series of prompts to get code of the same quality. We are accustomed to thinking as we write, so shifting to an “AI manager” mindset can be a difficult transition for non-managers.

This step also includes manual tasks like adding links and images, which cannot be automated with AI. You decide:

• which web pages are most relevant;

• how to get images: Google search, AI generation, non-AI diagramming, or a mix.

By the way, AI IDEs aren’t great at image generation yet—you have to use ChatGPT, Gemini, or specialized image generators.

Step 5. Committing Before AI Changes

In plain English, a “commit” saves a snapshot of your workspace files to Git with a message. Git is the most popular version control system for developers. You have to install Git on Windows, while it’s built-in on macOS. To use Git in Cursor, Trae, or VS Code, follow this guide; clone or initialize a Git repository.

In the IDE, use the Commit button in the Source Control tab.

• For the first commit of a post, start the message with feat: to follow conventions.

• After the colon, add the article code (folder name).

• There is no need to write longer commit descriptions if you follow this workflow.

• AI-generated commit messages work well for code but not for prose.

You also need to understand the “push” command, which sends committed files to a remote repository (typically GitHub). In the IDE, pushing is done by clicking “Sync Changes” button after committing.

Always commit before refining to effectively track upcoming AI edits.

Step 6. AI-Driven Refining and Polishing

Prompt the agent: Enhance #file-name1.md #file-name2.md according to article_rules.md. With less attentive AI models like GPT-5, it’s best to copy the most critical rules into the prompt, for example:

Re-write ONLY sentences which are hard to read, poorly written, redundant or repetitive, to improve clarity and make them sound better. Ensure that you make as little change to the original text as possible.

In response, the agent analyzes the folder and edits the given file(s). While Accept/Reject controls appear in the editors, the way the IDE highlights differences between the old and new versions of a long paragraph is not very convenient.

Therefore, it’s better to open the changed file in the Source Control tab. You’ll see the last committed version on the left and the AI-enhanced version on the right, with word-level diffs:

Colored highlights reveal exactly which words were changed, added, or removed.

• Correct the right-side edits if needed, including by copying phrases from the original left-side version.

• Click Accept when a paragraph looks good (if you didn’t do it in bulk before).

• If your original is better, restore it using the right-arrow button located between the two versions. This is possible even after accepting changes.

Final Steps

When all section files are ready, build them into a single, ready-to-publish document.

• Use a simple Python script to combine sections into one Markdown file. Run: python sections_to_one.py “parent-folder-name/main-folder-name”. Using AI for this concatenation would be unnecessary overhead.

• For most blogging platforms, Google Docs is the best intermediate. When the file content is in your clipboard, use “Paste from Markdown” (enable it in Tools → Preferences if missing). It supports key Markdown features, including “---” separators.

The only thing to do manually in Google Docs is to insert images where you see placeholders. If this seems too tedious and you’re tech-savvy, you can vibe-code a Markdown-to-HTML conversion and fill a Google Doc via its API, uploading images to a public URL that the Google Docs can fetch.

The Best AI IDE Features

I use Trae IDE for writing texts for three main reasons:

• Diff-based review of AI enhancements (see Step 6).

• Reusing typical AI instructions across posts. I don’t even need to reference the instructions as a file. In Trae, this is enabled by rule files, here is the main one: project_rules.md

• Reusing previous articles as my writing style examples, which provides important context for the AI.

As for the famous Tab Autocompletion, it also considers the file contents as context for the AI. However, you can’t control that context.

For creative writing, autocompletion tends to produce templated wording and paraphrased repetitions—fine for code, but a recipe for AI slop in prose. I don’t recommend relying on tab autocompletion for long-form writing. I turned it off.

Generating an outline from a brain dump and creating draft section files from it are time-consuming technical operations. Using AI here saves time, but it’s not a game-changer. Expanding a text with AI often doesn’t help much either.

What helps most is AI refining (Step 6), especially when combined with word-level comparison in the IDE.

AI Models to Use for This Workflow

For Step 6, I performed a lot of tests and finally opted for the Gemini Pro model.

Unlike OpenAI’s GPT models, Gemini makes only essential changes as required. Unlike Claude, it sounds more natural in English and corrects overly direct translations from Russian. However, Gemini is bad at outlining for some reason.

For most of the previous steps, I used to select Claude Sonnet models: 3.5, 3.7, 4.0.

This is because Claude follows instructions diligently and doesn’t make its own random decisions. However, Claude was removed from Trae in November 2025, as Anthropic tightened its policy restricting its use on Chinese-owned platforms.

So, I switched to GPT-5 High. It thinks longer, but its outcome is sometimes even better than Claude’s. For example, GPT-5 found and used an example of my previous outline. This idea hadn’t occurred to me before, but I liked it and added a corresponding instruction to outline_rules to make outlining even more stable.

I noticed only two pitfalls with GPT-5 when I used another workflow starting from a draft post rather than a brain dump:

• Sometimes, it removes random hyperlinks at Step 3.

• Rephrasing by GPT-5 can lose the original emotion or details.

Nevertheless, these drawbacks don’t matter for the braindump-based workflow described above. Just use Gemini at the refining step.

Conclusion

Workflows like mine can be implemented in less “software-oriented” workspaces too. If you need AI for complex artifacts, such as long posts in a consistent authorial style, you’ll likely spend more time in ChatGPT than in Cursor. But for many simpler workflows, an IDE is too heavy.

In upcoming Substack posts, I plan to broaden the AI workspaces picture. In particular, I’ll compare IDEs with Google Workspace and Microsoft 365, which already have powerful AI features.