Workflow Mastery: Automate, Accelerate, Personalize

Part 2 of 3 in the Cursor Mastery series

🧪 Interactive Lab Available: Prompting for Developers Lab →

Practice these workflows with hands-on exercises.

Explain This to Three People

The Time Audit Nobody Wants to Do

Let me show you something uncomfortable.

Last month, I tracked a full week of my dev time—every minute, every context switch, every "quick Google search" that turned into 30 minutes of Stack Overflow rabbit holes.

Here's what I found:

My Week BEFORE Intentional Cursor Use

20% of my time on creative work I love.

65% of my time on grunt work AI could handle.

My Week WITH Cursor Workflows

Result: 45% creative work. 10 more hours per week doing what I love.

The cost? 4 hours learning. One-time investment, permanent return.

The Three Interfaces (Choose Wisely)

Most people use Cursor like fancy autocomplete.

That's like using a Ferrari to grocery shop.

Each mode is designed for specific tasks. Match the mode to the task = 10x output.

The Decision Matrix

TASK COMPLEXITY
       ↑
HIGH   │  COMPOSER          CHAT
       │  (Multi-file)      (Planning)
       │      ▲                 ▲
       │      │                 │
       │   Build              Explore
       │   Refactor           Understand
       │   Features           Learn
       │      │                 │
MEDIUM │ ─────┼─────────────────┼──────
       │   INLINE               │
       │   (Cmd+K)              │
       │      ▲                 │
       │   Quick edits          │
       │   Bug fixes            │
LOW    │   Single function      │
       └──────┴─────────────────┴──────→
           SINGLE    →    MULTIPLE
                 SCOPE

Mode 1: Inline (Cmd+K) - The Precision Tool

When: Single-file, focused changes. You know what you want.

Think: Surgical strike. In-and-out.

Perfect For:

✓ Function edits

// You're here ↓
function calculateTotal(items: Item[]): number {
  return items.reduce((sum, item) => sum + item.price, 0);
}

// Cmd+K: "Add 8.5% tax calculation"
// Done in 5 seconds

✓ Adding error handling

async function fetchUser(id: string) {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
}

// Cmd+K: "Add try-catch with proper error handling"

✓ Type fixes

function processData(data: any) { // ← Cmd+K here
  // Prompt: "Replace any with proper TypeScript types"
}

When Inline FAILS:

• ❌ Need multiple files
• ❌ Unsure what the fix is
• ❌ Need broader context
• ❌ Exploring, not executing

Mode 2: Composer (Cmd+I) - The Builder's Workshop

When: Multi-file operations, features, structural changes.

Think: Your AI junior dev who can touch multiple files but needs clear direction.

Perfect For:

✓ Cross-file features

"Add 'favorites' feature:
1. @backend/db/schema.ts - favorites table
2. @backend/api/favorites.ts - CRUD routes
3. @frontend/components/FavoriteButton.tsx - UI
4. @frontend/hooks/useFavorites.ts - data hook

Follow patterns from @backend/api/posts.ts"

✓ Large refactors

"Refactor all class components in @components/ to 
functional components with hooks. Preserve all functionality."

✓ Consistent changes

"Add logging to all API routes in @api/:
- Use @utils/logger.ts pattern
- Log: request start, duration, errors, user ID"

The Composer Flow:

• Give clear, structured prompt
• Wait for full generation
• Review diff view (critical)
• Accept good / reject questionable
• Iterate if needed
• Apply and test

Mode 3: Chat (Cmd+L) - The Thinking Partner

When: Learning, planning, understanding, exploring.

Think: Pair programming with infinite patience.

Perfect For:

✓ Code explanation

"Explain @services/auth.ts:
1. How tokens are generated
2. Where they're stored
3. Security considerations  
4. Potential vulnerabilities"

✓ Architecture questions

"I need real-time notifications. Looking at @backend/server.ts,
should I use WebSockets, SSE, or polling? Trade-offs?"

✓ Debugging strategy

"This test fails: [output]
Code: @components/UserProfile.tsx
Help me understand what's wrong and how to fix it."

✓ Codebase tours

"I'm new to this repo. 10-minute tour of @src/:
1. Main architecture
2. Key files
3. Common patterns
4. Where to start"

When Chat FAILS:

• ❌ You know exactly what to do (use Inline/Composer)
• ❌ Need code written, not explained
• ❌ Avoiding reading docs you should know

The 5 Workflow Recipes (Copy These)

These are my most-used patterns. Steal them.

Recipe 1: The Refactor

Tool: Composer

Time: ~3 hours → 30 minutes

The Prompt:

"Refactor @components/Dashboard.tsx from class to functional:
- Convert state to useState
- Lifecycle → useEffect  
- Preserve all functionality
- Keep prop interface
- Add TypeScript types
- Follow @components/Profile.tsx patterns
Test: npm run test Dashboard"

Review Checklist:

• [ ] State converted correctly?
• [ ] useEffect dependencies right?
• [ ] No missing lifecycle logic?
• [ ] Tests pass?

Failure Mode: Missing componentDidUpdate edge cases.

Fix: Specifically call out complex lifecycle methods.

Recipe 2: The Test Generator

Tool: Chat → Review → Inline

Time: ~2 hours → 20 minutes

The Flow:

You: "Generate Jest tests for @api/users.ts:
- Happy path (CRUD)
- Errors (400, 404, 500)
- Edge cases (empty, malformed)
Use @tests/api/posts.test.ts patterns"

[Cursor generates]

You: "Add rate limiting tests"
[Cursor adds]

You: "Make assertions more specific on line 23"
[Cursor refines]

Review:

• [ ] Tests behavior, not implementation?
• [ ] Mocking makes sense?
• [ ] Edge cases covered?

Failure Mode: Tests pass but don't catch bugs.

Fix: Run against intentionally broken code to verify they fail correctly.

Recipe 3: The Legacy Decoder

Tool: Chat

Time: ~1 hour → 10 minutes

The Prompt:

"Explain @utils/dataProcessor.js:
1. Main purpose?
2. Key functions?
3. Dependencies and why?
4. Side effects?
5. Potential bugs?
6. How would you refactor this?"

Follow-ups:

• "What does `transformLegacyFormat` do?"
• "Why setTimeout in `processQueue`?"
• "Is this race condition real?"

Pro Tip: Ask Cursor to prove it with logging/tests.

Recipe 4: The Feature Scaffold

Tool: Composer

Time: ~4 hours → 45 minutes

The Prompt:

"Implement 'export to CSV':

Backend (@backend/):
- @routes/export.ts - GET /api/export/:type
- @services/export.ts - CSV generation
- Follow @routes/users.ts auth pattern

Frontend (@frontend/):
- @components/ExportButton.tsx - UI + loading
- @hooks/useExport.ts - API hook
- Follow @components/ImportButton.tsx patterns

Requirements:
- Error handling
- Loading states
- TypeScript
- Add tests to @tests/"

Your Job:

• Review architecture
• Refine business logic
• Edge case handling
• Integration tests

Recipe 5: The Documentation Sprint

Tool: Composer or Chat+Inline

Time: ~2 hours → 15 minutes

The Prompt:

"Add JSDoc to all functions in @utils/:
- Description
- @param with types
- @returns  
- @example with realistic use
- @throws if applicable
Match @core/auth.ts style"

Quality Check:

• [ ] Examples work?
• [ ] Clear to newcomers?
• [ ] Types match?

The Anti-Patterns (Learn From My Pain)

❌ Accept-All Syndrome

What it looks like:

[Composer generates 500 lines]
You: "Looks good!" [Accept]
[Later]: "Why doesn't this work?"

The fix: Review. Line. By. Line. If you wouldn't stake your reputation on it, don't ship it.

❌ Context-Free Prompting

Bad:

"Add error handling"

Good:

"Add try-catch to @api/users.ts:
- Catch network errors separately
- Log to @utils/logger
- User-friendly messages
- Follow @api/posts.ts pattern"

Specificity = Quality.

❌ Skipping the Review

Wrong flow:

Prompt → Generate → Apply → Ship

Right flow:

Prompt → Generate → REVIEW → Question → Refine → Apply → Test → Ship

That review step is everything.

The Time Audit Challenge

Want proof these workflows work? Do this:

Week 1: Baseline

• Track time on: Debugging, Boilerplate, Refactoring, Learning
• Note frustration points
• Count context switches

Week 2: Intentional Cursor

• Pick 3 workflows
• Track same categories
• Note what worked

Week 3: Reflect

• Calculate time saved
• Identify highest-ROI workflows
• Build your prompt library

My prediction: 6-10 hours saved. At least.

What's Next

→ Article 3: "Problem-Solving & Community" (next week)

Real debugging. Real contributions. Real impact.

Try This Now

Path A: The Time Auditor

Track tomorrow. One day. See where time goes.

Path B: The Recipe Tester

Pick ONE workflow. Try it today. Real task.

Path C: The Lab Student

Complete the Prompting lab →

50 minutes of guided practice.

The Real Transformation

It's not about speed.

It's about spending your time on work that matters.

Before: drowning in maintenance, tests felt like punishment, docs were always "later."

Now: Tests write themselves. Docs stay current. Refactors happen.

My brain is free for the hard problems.

That's the unlock. Not speed. Freedom.

Previously: Article 1: Cursor Mindset →

Next up: Article 3: Problem-Solving & Community → (Dec 15)

Practice now: Prompting Lab → | Cursor Basics →

Part 2 of the Cursor Mastery series. Download [the workflow recipe library](#) or start [the interactive labs](/learn-ai-lab).