Why I Write Everything in My IDE Now

I refuse to write content in anything but my IDE anymore. Not because I'm a developer trying to be edgy—because AI coding assistants fundamentally changed what's possible when creating content.

The Real Innovation: Velocity

The actual innovation isn't "AI can write." It's the prompt → approve/deny → ship loop. When AI handles all the low-level synthesis work, you can go from idea to published content in minutes instead of hours.

This loop exists in most AI apps now. What makes coding assistants different is scale and context. I can pull from any file in the repo for context. I can fetch from any URL with tool use. I can write to multiple pages and files simultaneously. I can write to 1 page, 10 pages, 100—doesn't matter. The AI has full repo context and can create, edit, and synthesize across the entire project.

Go try to do this in Notion, Obsidian, or Google Docs. You can't. That's the leverage difference.

What Traditional Writing Tools Can't Do

Repo-Wide Context

When I'm writing an article about a component I built, the AI can read the actual component code, the tests, the related components, the documentation—everything. It knows the project structure, the conventions, the design patterns.

In Notion or Google Docs? I'd have to manually copy-paste context, hope I included the right pieces, and constantly switch between tools.

Multi-File Operations

I can generate 10 related articles in one conversation. The AI creates the files, adds proper metadata, handles cross-linking, ensures consistent terminology, and even updates the navigation if needed.

In traditional tools, that's 10 separate documents, manual linking, manual organization, and hoping you remembered to use the same terms across all of them.

URL Context Integration

Need to reference something from the web? The AI can fetch it, extract the relevant information, and synthesize it into the article. No switching tabs, no manual copying, no context loss.

Instant Publishing

My IDE is also my deployment pipeline. Edit → save → git push → deployed. The content I'm writing IS the production content. There's no export step, no conversion, no "now copy this to the CMS."

The Scale Advantage

When you eliminate friction, you change what's worth doing. It's now worth it to:

• Document every feature as I build it
• Write detailed explanations of debugging sessions
• Create comprehensive guides for tools I use
• Generate related articles from a single conversation
• Maintain up-to-date documentation without it feeling like overhead

The activation energy is so low that documentation becomes a natural part of development, not a separate chore.

The Curation Problem

When you can generate this much content, the bottleneck shifts from creation to curation. Not everything needs to be published. Not everything is worth the same attention.

This is where transparency becomes important. When readers encounter AI-synthesized content, they want to know why you thought it was worth creating. That's where human context matters—voice notes, author commentary, curation decisions. (See VoiceNote Component for how I'm handling this.)

What This Enables

Ship Daily

I can realistically publish something every day I code. Even small features or debugging sessions become publishable content because the synthesis work is handled by AI.

Build in Public

Documentation isn't an afterthought—it's generated as part of the development process. My commit history and my content archive are synchronized.

Knowledge Compounding

Every article references previous work. The AI can pull from the entire corpus when writing new content. Knowledge builds on itself instead of existing in isolated documents.

The Workflow

.md

Me: "Write an article about the Timeline component I just built. 
     Include the architecture, the bugs I fixed, and why I chose SVG."

AI: [reads Timeline.tsx, reads related components, reads git history]
    [generates comprehensive article with code examples]
    [creates content/tsx/building-timeline-component.tsx]
    [adds proper metadata and tags]

Me: [reviews, approves, makes minor edits]

git add . && git commit -m "Add Timeline component article" && git push

Done. Published.

Start to finish: 5-10 minutes. The same workflow in a traditional writing tool would take hours—gathering context, formatting code, organizing sections, exporting, uploading.

Why This Matters

Most developers aren't documenting their work not because they don't want to, but because the friction is too high. When documentation requires context switching, manual formatting, and separate publishing steps, it doesn't happen.

AI coding assistants eliminate that friction. Not by "writing for you," but by handling the synthesis and formatting while you focus on curation and direction.

The result: more documentation, better knowledge sharing, and a more connected development process.

Anthropic Figured It Out

Anthropic clearly noticed that developers had something special going on. Coding assistants weren't just helping people code faster—they were enabling entirely new workflows.

So they built Claude Cowork: an attempt to bring this paradigm to general audiences. Multi-file context, project-wide understanding, integrated file operations—all the capabilities that developers have been using for content creation, now packaged for non-technical users.

The bet: developers accidentally discovered the future of knowledge work. Not because developers are special, but because coding assistants happened to solve the fundamental problems first: context management, multi-document operations, and precision editing of both code and content using natural language.

They realized the secret sauce wasn't coding—it was the infrastructure for working with structured information at scale. Developers just got there first because our work happens in file systems, git repos, and IDEs that already had the right primitives.

OpenAI Launches Codex App (Feb 2, 2026)

Today, OpenAI announced the Codex desktop app—their answer to Claude Cowork. The pitch? "Codex is designed to close the gap by making it easier to direct, supervise, and apply the full intelligence of our models to real work."

They added skills for document creation: PDF, spreadsheet, and docx files. Image generation. Deployment automation. Linear integration. The exact same pattern—take the coding agent infrastructure and apply it to everything else.

This is validation that the insight is real: the best interface for AI-assisted knowledge work looks like a coding environment. Not because you're writing code, but because the primitives (file operations, version control, multi-document editing, context management) are exactly what you need for working with information at scale.

Both companies saw developers having "aha" moments—not just coding faster, but using these tools to write, document, create, and think. Now they're racing to productize it.

The Meta Point

This article itself is an example of the workflow. I had a conversation about voice notes, realized I was actually talking about two different topics, and within minutes had this article created, organized, and ready to publish.