My AI Coding Workflow

I've been talking to myself on walks for years. The dog doesn't mind. What changed is now those ramblings actually turn into shipped code.

Here's what my workflow looks like right now. It's a little weird.

Walking and talking

Most of my ideas don't show up when I'm at a desk. They hit me when I'm moving — walking the dog, driving, pacing the backyard. I used to lose these. Now I just open Voice Memos and start talking.

It's not structured. I'm literally thinking out loud. "Okay so the problem is... and maybe we could... but wait, what about..." Stream of consciousness. Half-baked technical hunches. Random edge cases.

Your ramblings are considerably better than starting an agent with too little context.

Claude for the thinking

When I get back inside, I dump the transcript into Claude on my phone. Not Claude Code yet — just regular Claude with a Project set up for this kind of thing.

This is where I figure out what I'm actually building. Claude asks good questions. "What's the MVP here?" "Do you really need that feature for v1?" It's like having a PM in my pocket who isn't afraid to push back.

By the end of this conversation, I've got something resembling a PRD. Nothing fancy — just clear enough that I could hand it to someone and they'd know what to build.

Planning in Claude Code (still on my phone)

Now I open Claude Code and connect to the repo on my phone. Claude Code can see the actual codebase, so it can tell me how to build the thing, not just what to build.

I'll paste in the PRD and we'll work through implementation. Which files to touch. What the approach looks like. Sometimes I have it drop a PLAN.md in the repo so I don't forget.

This all happens from the couch. Or waiting in line somewhere. I'm using dead time to do the thinking so I can just execute when I'm at my desk.

What a real prompt looks like

Here's an actual prompt I sent to kick off a PRD for a customer-facing app. Notice it's not clean — there's links, pointers to existing code, half-formed ideas.

I'd like to scope out a PRD for a new application we're building 
in the GTM Monorepo. This application is a customer facing 
application. Explore the codebase to understand our existing 
patterns prior to writing the PRD. Also consult documentation 
where needed on the web.

Relevant thoughts from the ramble:
- https://vercel.com/geist/brands
- geistcn lives in the front monorepo and is based on shadcn
- we pull crux data in several places in the GTM monorepo, 
  look for those examples prior to consulting the web
- I like the idea of doing loading page comparisons similar 
  to lightest.app — could use browserbase to capture screenshots 
  and upload to Vercel Blob

Top of mind ramble: Alright, so the top of mind ramble is let's...

Back at the computer

I open Claude Code in the terminal and resume the session. Everything's still there — the whole conversation, the plan, the context. I say "let's start" and we're off.

For straightforward stuff, I let Claude Code run. It writes code, I review the output. Multiple turns, mostly hands-off.

Sometimes it struggles. Maybe the codebase has weird patterns, or the logic is from a new lib not yet in the training set.

That's when I switch to Cursor.

Cursor is better for surgical work. I'll write code manually when I know exactly what I want, or use Cursor's agent mode with tight, focused prompts. "Fix this function, here are the docs to the API return values."

                         ┌─────────────────┐
            ┌───────────►│  Claude Code    │
            │            │  Resume/Start   │
            │            └────────┬────────┘
            │                     │
            │                     ▼
            │           ┌─────────────────┐
            │           │ Straightforward │──────────┐
            │           │    work?        │          │
            │           └────────┬────────┘          │
            │                    │ no                │ yes
            │                    ▼                   │
            │           ╔═══════════════╗            │
            │           ║    CURSOR     ║            │
            │           ║ ───────────── ║            │
            │           ║ Surgical work ║            │
            │           ║ Manual edits  ║            │
            │           ║ Tight prompts ║            │
            │           ╚═══════╤═══════╝            │
            │                   │                    │
            │                   │ foundations set    │
            │                   ▼                    │
            │           ┌─────────────────┐          │
            │           │  Claude Code    │◄─────────┘
            │           │ ─────────────── │
            │           │ Finish PRD      │
            │           │ Polish UI       │
            │           │ Error handling  │
            │           │ Write tests     │
            │           └────────┬────────┘
            │                    │
            │                    ▼
            │           ╔═══════════════╗
            │           ║  FINAL PASS   ║
            │           ║   in Cursor   ║
            │           ║ ───────────── ║
            │           ║ Review code   ║
            │           ║ Run tests     ║
            │           ╚═══════╤═══════╝
            │                   │
            │                   │ next feature
            └───────────────────┘

After I've gotten through the sticky part and setup better foundations I'll switch back to Claude Code.

"Finish this PRD. Polish the UI as an expert UX researcher would. Add error handling in case XYZ API is down. Write E2E Playwright tests for the critical user journey."

Claude has gotten better and better at solving its own problems lately so I find myself pasting in the right docs and getting out of the way.

Final cleanup happens in Cursor. Reading through the code, catching anything weird, running the app and tests manually. Quick edits, nothing fancy.

The whole thing works because I'm not sitting down to a blank file wondering where to start. By the time I'm actually writing code, I've already thought through what I'm building, talked it out, made a plan, and know roughly where everything goes.

Voice memo → Claude → Claude Code → Cursor → ship.