Claude Code for Writers

Update: Anthropic released Cowork on January 12, 2026, which brings similar file-access capabilities to Claude Web without the terminal. The insights here about context management apply to both. I still prefer Claude Code for the reasons below, but Cowork offers a gentler entry point if you find Terminal intimidating.

One of my team members recently asked how I use Claude Code for editorial work. The question caught me off guard. Because the answer has changed so much since I fired up Claude Code. What started as a curiosity about context management has become my primary creative tool. Not just for writing, but for presentations, mockups, and now actual software.

This isn't a prompt guide or a list of hacks. It's an attempt to articulate something I've been circling for months: Claude Code isn't really about code (although it's very good at that). It's about directing context. And that realization changed how I work.

Opening Terminal for the first time

I was an early OpenAI user through Jasper, back when writers used AI privately and felt guilty about it. Eventually I moved to Claude's web interface. The writing felt more human than ChatGPT. But I kept hitting context limits. Long projects would lose track of earlier decisions. I'd re-explain things constantly.

Then I heard Dan Shipper on Lenny's Podcast describe using Claude Code as an editorial leader. That didn't make sense to me. Claude Code was for engineers. Why would a content person use a terminal?

But his example stuck: Claude Code can access your entire filesystem. Read documents, reference past work, execute tasks. It piqued my curiosity enough to do something intimidating. Open Terminal on my Mac for the first time in my life.

I remembered my days working at Apple. I was never on a technical team. But I'd watch the Geniuses constantly logging into Terminal. It seemed like a secret language for talking directly to the machine.

That's exactly what Claude Code turned out to be. A way to use AI to communicate directly with your computer. Not through a chat window that forgets everything, but through a persistent connection to your actual files and tools.

The first project

My first real use was preparing for a speaking event in 2025. I needed a template to share with the audience and visual mockups I could screen-record for my slides.

Claude Code built them in HTML. Not artifacts in a chat window. Actual files I could open in a browser, tweak, record. That shift from "artifact" to "real file on my computer" was the first unlock. Suddenly I wasn't constrained by what the web interface could render. I had a tool that could create anything I could describe (within reason).

From there, my capabilities grew because my understanding of what was possible grew. I started mocking up graphics to explain concepts to my team. Using it for strategy ideation. Editing and reviewing content. Each project taught me something about context management.

Then I started asking Claude what it could actually do. Could it build real software, not just prototypes? I'd been put off by other tools due to limitations in execution and maintenance headaches. But Claude explained it differently. It could control tools on my computer. Build codebases in Xcode. Teach me to iterate.

So I experimented. And years of communicating clearly with collaborators paid off. I had patience. I knew how to give feedback that moved things forward. The process was a joy because I'd already developed the underlying skill without realizing it.

Context, not code

Here's what I eventually understood: Claude Code is a context management tool. The "code" part is almost incidental. What makes it powerful is its ability to read, reference, and act on information across your filesystem.

When you attach a file in the web interface, you're uploading it to a conversation that will eventually forget it. When you reference a file in Claude Code, you're giving it a path to something persistent. It can read it, modify it, check back on it later. That's a different relationship entirely.

This reframing helped me see why certain skills transfer so directly. Managing context is something many professionals already do. Knowing what information to surface, when to surface it, how to structure it for clarity. That's the same skill as setting up a project folder for Claude Code.

The CLAUDE.md file

Before Claude Code, I was loading up the web interface's project description with context. It worked, sort of. But Claude would miss things. Forget guidelines. Lose track of decisions.

The CLAUDE.md file changed that. It's a markdown file at the root of any project that Claude Code treats as a source of truth. Not a suggestion. A source of truth. It reads it at the start of every conversation. It takes the contents seriously in a way the web interface never did with project descriptions.

This was immediately familiar to me. A CLAUDE.md file is like a project brief or guidelines document. The same document that tells a team what standards to maintain, what decisions have been made, what the goals are. I'd been writing these for years. Now I was writing them for an AI.

This structure works for software projects, presentations, creative projects. Anything. The CLAUDE.md captures scope, philosophy, decisions made. The reference folders hold everything Claude might need to look at. The archive keeps old versions without cluttering the main space.

I used to download files without a plan. Now I organize them intentionally, because I know Claude navigates via file paths. Good folder structure is good context engineering.

The infinite loop

The real unlock came when I started treating the CLAUDE.md as a living document. Every conversation that surfaces something valuable goes back into the file. A decision, a refinement, a lesson learned.

This creates compounding context. Each conversation starts smarter than the last because the CLAUDE.md has accumulated everything worth knowing. I'm not re-explaining my preferences every session. I'm not losing decisions to forgotten chat history. The project remembers itself.

I have a high-level CLAUDE.md for my entire product studio that understands all my tools in development, archived ideas, design philosophy, even my goals. When I start brainstorming something new, it holds me accountable to what I've already decided. It knows the portfolio strategy. It can tell me when an idea doesn't fit.

Skills that transferred

I didn't expect my background to matter for a "coding tool." But the skills that make you good at communication and project management are exactly what make Claude Code useful.

Patience with iteration. Good output rarely comes on the first pass. You give feedback, it revises, you refine based on what you see. The patience I'd developed for collaboration translated directly.

Clarity in communication. Vague requests produce vague results. I'd learned to be specific. Not prescriptive, but clear about intent. That skill matters even more with AI, where ambiguity gets interpreted rather than questioned.

Knowing what to surface. What context does someone need to do good work? What can be left out? Same question with Claude Code. What files should it read? What should stay in the CLAUDE.md versus a reference folder?

Discoveries along the way

Some things I learned that surprised me:

Permission-based workflow. Claude Code asks before editing files, running commands, or making changes. This felt different coming from the web interface. Many actions require approval unless you configure otherwise. It forces intentionality. And it works well for creative projects, not just engineering.

Web search requires instruction. Unlike the web interface, which often searches automatically, Claude Code is more conservative. It will search if you ask or if it really needs to. Otherwise it works from what it knows. Keep this in mind if you need current information.

It can grab tools on the fly. I needed to make an icon background transparent. Claude downloaded an image processing tool and did it itself. I didn't have to install anything manually. It just handled it.

Google Docs comments survive export. When reviewing long articles with dozens of comments, I download the Google Doc as a text file. Claude can see all the comments and understand how they relate to specific sections. The web interface can do this too, but having the file persist in my project folder means I can reference it across sessions.

Multiple terminals, focused work

Something I've grown to love: running multiple Claude Code sessions at once.

It started with one terminal. Then two. Now when I'm deep in a project, I might have three or four open. Each focused on a specific task with specific context. One working on visuals, another on copy, another on technical implementation.

This parallelism was a shift. Instead of one long conversation trying to do everything, I have focused conversations that do one thing well. The Max plan makes this practical. More conversations, more context across them. Voice dictation makes this even more practical—I can speak to each conversation in turn.

The tactile feel

Something unexpected: I've grown to like the interface (pretty obvious from looking at my site design). It isn't as pretty as the web. Copy-pasting from Terminal into other apps can be janky. But there's something robust about it.

Working with files in Finder again. Organizing folders. Editing markdown directly. Everything feels tactile and real in a way that the web interface doesn't. The files are on my machine. I can see them, move them, back them up. They're not trapped in a chat history somewhere.

Writing is thinking. The way I communicate with Claude is the way I communicate ideas generally. Having my voice and thinking style captured in the CLAUDE.md means consistency across everything. Even when Claude is drafting, it knows how I reason.

The terminal isn't as foreign as it looks. Behind the intimidating interface is a simple idea: direct communication with your computer through an AI that can read and act on your files. If you've spent years managing context in any professional capacity, knowing what information to surface and how, you already have the core skill.

Claude Code didn't make me a developer. It made me someone who can direct development. The difference matters. I'm not writing Swift syntax from memory. I'm describing what I want, reviewing what Claude produces, and iterating until it's right. That's collaborative work with a different output. I shipped my first Mac app in a couple of months, with no coding experience.

I'm significantly more creative and productive than I was before. Not because Claude does the thinking for me, but because it removes friction between having an idea and seeing it exist. I highly encourage you to experiment with it, if you haven't already. When you see things come to life and learn to reinforce better context over time, it becomes a real joy to use.

This is a working document. My workflow keeps evolving as I learn what's possible.