The conversation around AI coding tools usually falls into two camps: “it writes all my code” or “it hallucinates imports.” Both miss the point.

The real unlock isn’t having AI write code for you — it’s changing how you think when you have a senior engineer available 24/7 who never gets tired.

My Stack (July 2026)

Role Tool Why
Primary coding Claude Code (Sonnet 4) Best reasoning, respects architecture
Fast edits / tabs Cursor (Sonnet 4) Inline diffs, Cmd+K speed
Local/private Ollama + Qwen2.5-Coder No data leaves machine
Research/Planning Perplexity + Gemini 2.5 Web access, large context
Code review Custom GitHub Action + Sonnet Catches what I miss

The Workflow Loop

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  SPECIFY    │───▶│  IMPLEMENT  │───▶│   VERIFY    │───▶│  ITERATE    │
│  (10 min)   │    │  (30 min)   │    │  (5 min)    │    │  (∞)        │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

1. Specify (Don’t Prompt)

Instead of “build me a dashboard,” I write a SPEC.md:

# SPEC: User Analytics Dashboard

## Requirements
- Real-time metrics via SSE
- Date range picker (presets + custom)
- Export CSV / PDF
- Responsive: mobile cards, desktop table

## Data Contract
GET /api/analytics?from=2026-01-01&to=2026-01-31
Response: { metrics: [{ date, views, signups, revenue }] }

## Acceptance Criteria
- [ ] Loads in <500ms on 3G
- [ ] Works offline (cached last fetch)
- [ ] Keyboard navigable

Claude Code reads this and implements the whole thing. No back-and-forth.

2. Implement (Delegate, Don’t Micromanage)

# In project root
claude "Read SPEC.md and implement the analytics dashboard. Use the existing UI components in src/components/ui. Follow the project's patterns."

Claude Code will:

  • Read your SPEC
  • Explore the codebase
  • Create files
  • Run tests
  • Fix TypeScript errors
  • Commit with conventional messages

3. Verify (Trust But Verify)

# Run the verification suite
npm run test && npm run typecheck && npm run lint

# Quick manual check
claude "Review the dashboard implementation against SPEC.md. Any gaps?"

4. Iterate (The Real Work)

The first pass is never perfect. But now you’re editing, not writing.

claude "The date picker needs to support fiscal quarters. Update the component and add tests."
claude "The CSV export is missing the revenue column. Fix the transformation."
claude "Add skeleton loaders while data fetches. Match the design system."

Key Principles

1. Context > Prompts

Give the AI your codebase, not just the task. Use @-references in Cursor, or let Claude Code explore.

claude "@src/components/ui/* @src/lib/api.ts Implement the dashboard using these patterns"

2. Enforce Architecture via CLAUDE.md

Every project gets a CLAUDE.md:

# Project Rules

- **State**: Zustand only. No Redux, no Context for server state.
- **API**: TanStack Query. All mutations invalidate queries.
- **Styling**: Tailwind + CSS variables. No styled-components.
- **Types**: Zod schemas → TypeScript types. Never write types by hand.
- **Tests**: Vitest. Unit for utils, integration for API routes.
- **Commits**: Conventional commits. `feat:`, `fix:`, `refactor:`.

The AI follows this. It becomes your architecture enforcer.

3. Use Skills for Repeatable Patterns

I have a skills/ folder with reusable patterns:

skills/
├── api-endpoint/      # Standard REST endpoint with validation
├── react-form/        # React Hook Form + Zod pattern
├── data-table/        # TanStack Table with server-side sorting
├── auth-flow/         # NextAuth + Prisma pattern
└── background-job/    # BullMQ job with retries
claude "Use the api-endpoint skill to create POST /api/webhooks/stripe"

4. Local Models for Sensitive Code

# Start local model
ollama run qwen2.5-coder:32b

# In Cursor: Cmd+Shift+P > "Ollama: Set Model"

Anything with API keys, PII, or proprietary algorithms stays local.

The “Don’t” List

Don’t Do
“Fix this bug” “The login flow fails when OAuth state expires. Reproduce in test, then fix.”
“Make it pretty” “Update the card component to match the design system: 12px radius, 2px border, hover elevation.”
“Refactor this” “Extract the date formatting logic into src/lib/date.ts with tests. Update all 7 call sites.”
Blindly accept Review every diff. Run tests. Think about edge cases.

Results After 6 Months

Metric Before After
Features shipped/month 8 23
Bugs in production ~12/mo ~3/mo
Code review time 45 min 8 min
Time to prototype 4 hours 45 min
Cognitive load High Low

The code quality improved because I have bandwidth to think about architecture instead of syntax.

Getting Started This Week

  1. Install Claude Code: npm install -g @anthropic-ai/claude-code
  2. Add CLAUDE.md to your project root
  3. Write one SPEC.md for your next feature
  4. Run: claude "Read SPEC.md and implement"
  5. Review, test, iterate

The first time you see a 500-line feature implemented correctly in 3 minutes — including tests — you’ll understand.

This post was written with Claude Code as a thought partner. The code examples are from real production projects. The workflow evolved over 6 months of daily use.