Forem: Xunxing Mao

AI Coding Playbook: Tool Selection, Workflows, and Prompt Templates

Xunxing Mao — Thu, 16 Apr 2026 01:22:57 +0000

This article was originally published on maoxunxing.com. Follow me there for more deep dives on AI-assisted development workflows.

Choosing AI Tools by Scenario

Different tasks call for different model and tool combinations:

Scenario	Recommended Approach	Reasoning
Reading comprehension	Qwen CLI + Qwen Coder	Fast, fewer hallucinations, low cost
Analysis scripts	Claude Code	Deep thinking, offers unique and unexpected statistical dimensions
Report generation	Cherry Studio + Claude Sonnet + specific template	Consistent design style, avoids the "AI flavor"

Common AI Tools

ChatWise -- Multi-model chat client
DeepSeek R1 -- Reasoning model
Gemini 2 Flash Thinking -- Fast reasoning model
Repomix -- Packages codebases for feeding to AI as a whole
Spark Desktop -- Desktop AI assistant

Cherry Studio Design Workflow

Cherry Studio + HTML enables rapid page design "card drawing." The core approach:

Like image generation, try to generate multiple outputs at once, then pick the best
Use HTML or SVG for rendering
To reduce response size, require AI to use TailwindCSS
Reference established design systems like Ant Design or Shadcn UI as background knowledge

UI/UX Designer System Prompt Template

Here is a field-tested UI/UX Design System Prompt suitable for Cherry Studio or similar tools:

# Role
UI/UX Designer Expert

## Notes
1. Encourage deep thinking about role configuration details to ensure task completion.
2. Expert design should consider the user's needs and concerns.
3. Use emotional prompting to emphasize the role's significance and emotional dimensions.

## Personality Type
INTJ (Introverted, Intuitive, Thinking, Judging)

## Background
The UI/UX Designer Expert role is designed to help users make informed decisions
in the visual design and user experience domain. This role provides professional
guidance and advice to help create beautiful yet functional interface designs.

## Constraints
- Must follow user-centered design principles
- Must consider cross-platform and multi-device compatibility

## Goals
- Provide innovative and practical UI/UX design solutions
- Enhance user satisfaction and product usability
- Optimize user-product interaction experience

## Skills
1. Visual design capability
2. User research and analysis
3. Interaction design
4. Technical implementation

## Tone
- Professional and insightful
- Encouraging innovation and experimentation
- Approachable and easy to understand

## Values
- User-first: all design centered on user needs
- Pursuing simplicity without sacrificing functionality
- Continuous learning and adapting to new technologies and trends

## Workflow
1. Understand user requirements and goals
2. Conduct market research and competitive analysis
3. Determine design direction and style
4. Create prototypes and interaction flows
5. Conduct user testing and collect feedback
6. Iterate based on feedback
7. Deliver high-quality design output

# Initialization
Hello, let us think step by step, working diligently and carefully.
Please follow the Workflow step-by-step according to the chosen role to achieve the Goals.
This is very important to me -- please help. Thank you! Let's begin.

# Output Format
Return the final design result in HTML, using TailwindCSS for styling.

Core Questions for AI-Assisted Development

When promoting AI programming within a team, consider these questions:

Tool comparison: What are the respective use cases for Cursor's built-in browser Agent vs. chrome-devtools-mcp?
Product form: What distinguishes Claude Code and Codex from an IDE?
Team generalization: Can current AI programming practices scale to other team members?
Engineering standards: What are the engineering standards? How are they established? Are they high-cohesion, low-coupling?
AI as challenger: Let AI raise questions for me, filling in missing perspectives -- AI as Code Reviewer and proposal challenger
Tech Lead perspective: What questions does a Tech Lead care about? How do I answer them?
Memory management: How to effectively maintain context with Cursor Memory Bank?

Prompt Template Library

Code Reading

What does this code implement? Please provide a detailed introduction, create a
colored table diagram or generate a visualization to aid understanding. Also output
a minimal runnable version of the code -- no error handling, no edge cases, no logging.

Article / Note Organization

Help me organize this into better Markdown format (add a table of contents if there
is a lot of content). Please ensure no content is lost; minor additions are fine.
Organize everything in Markdown so I can copy and use it directly.

Book Report

Help me organize this into better Markdown format. Please ensure no content is lost;
minor additions are fine. Organize everything in Markdown so I can copy and use it
directly. Required format:

A 50-word summary

---

## What I Liked

## What I Disliked

## Key Takeaways

Paper Reading

List the distinctive methods used in this paper. Compare them with previous techniques.
Give me a list that is extremely specific about what they did differently compared to
prior work.

Codebase Improvement

Hello AI, here is my entire codebase. Tell me 10 ideas for how I can improve it.

High-Quality Answer Pre-check

Don't rush to answer my question yet. In order to produce a higher-quality answer,
what additional information do I need to provide?

Writing Style Switches

"Please rewrite this article in a Hemingway style." -- Short sentences, direct, powerful
"Rewrite it in the style of Stephen King's On Writing." -- Narrative drive, rhythm, vivid imagery

References

Cursor Documentation — Official documentation for Cursor AI-powered code editor
GitHub Copilot Documentation — Official GitHub Copilot documentation covering setup and best practices
Prompt Engineering for Developers — DeepLearning.AI — Free course on prompt engineering techniques for software development

Node.js CPU Spike Analysis: When Requests Hang and Event Loop Starves

Xunxing Mao — Tue, 14 Apr 2026 01:27:23 +0000

This article was originally published on maoxunxing.com. Follow me there for more deep dives on Node.js, AI, and frontend engineering.

The Problem

In production environments, we often encounter a peculiar phenomenon: CPU usage suddenly spikes to 100% while the application appears to be "doing nothing." No active computations, no heavy processing—just hanging requests and a frozen event loop.

This article analyzes two real-world cases from a large-scale operation platform:

RPC batch processing timeout causing CPU spikes
Message queue subscriber CPU anomalies without rate limiting

Case 1: RPC Batch Processing - The Silent Killer

The Scenario

We have a getBatchCompleteModuleDiff method that processes 100 components in batches. Each component triggers 4-5 RPC calls to backend services.

// Before optimization - Serial processing, NO timeout
async getBatchCompleteModuleDiff(componentIds: number[]) {
  const chunks = chunk(componentIds, 5)  // 20 batches for 100 components
  let result = []

  for (const chunkItem of chunks) {  // Serial execution!
    const res = await Promise.all(
      chunkItem.map(id => this.getCompleteModuleDiffInfo(id))
    )
    result.push(res)
  }
  return result
}

Why CPU Spikes When Requests Hang

The root cause is Event Loop Starvation caused by the combination of:

No timeout control - RPC calls could hang indefinitely
Promise accumulation - 20 batches × 5 components × 4 RPC calls = 400+ concurrent Promises
Event loop blocking - All Promises compete for event loop cycles

Here's what happens:

Timeline:
├── Batch 1 starts (5 components × 4 RPC calls = 20 Promises)
├── Batch 1 hangs (backend database exception, no timeout)
├── Batch 2 starts (another 20 Promises)
├── Batch 2 hangs
├── ...
├── Batch 20 starts (another 20 Promises)
├── Event Loop: 400+ pending Promises waiting
└── CPU: 100% (event loop constantly checking Promise states)

The CPU isn't doing useful work—it's spinning on Promise resolution checks.

The Solution

// After optimization - Parallel batches with timeout
async getBatchCompleteModuleDiff(componentIds: number[]) {
  const componentIdsChunks = chunk(componentIds, 10)  // Larger chunks

  // Parallel processing with timeout protection
  const batchPromises = componentIdsChunks.map(async (chunk) => {
    const promises = chunk.map(id => 
      this.withTimeout(
        this.getCompleteModuleDiffInfo(id),
        5000,  // 5s timeout prevents indefinite hanging
        `timeout for id: ${id}`
      )
    )
    return Promise.allSettled(promises)  // Isolate failures
  })

  return Promise.all(batchPromises)
}

private withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMsg: string): Promise<T> {
  return new Promise((resolve, reject) => {
    const timeoutId = setTimeout(() => reject(new Error(errorMsg)), timeoutMs)
    promise
      .then(result => { clearTimeout(timeoutId); resolve(result) })
      .catch(error => { clearTimeout(timeoutId); reject(error) })
  })
}

Results

Metric	Before	After	Improvement
Response Time	60s+	5-8s	87% ↓
CPU Usage	90-100%	40-50%	50% ↓
Timeout Control	None	5s	Prevents hanging

Case 2: Message Queue Subscriber - The Rate Limiting Problem

The Scenario

Our CheckTaskResultSubscriber processes message queue messages for inspection task results:

@MessageSubscriber({ topic: 'TASK_RESULT' })
export class CheckTaskResultSubscriber implements IMessageSubscriber {
  @Inject()
  checkReportService: CheckReportService

  async subscribe(msg: SubscribeMessage) {
    const messageBody = JSON.parse(msg.body.toString())

    if (this.INSPECTOR_TAGS.includes(messageTag)) {
      await this.handleInspectorResult(messageBody)  // DB operations
    } else if (this.DETECTION_TAGS.includes(messageTag)) {
      await this.handleDetectionResult(messageBody)  // DB operations
    }
  }
}

Why CPU Spikes Without Rate Limiting

Message queue consumers by default pull messages as fast as possible. When:

Message burst occurs (e.g., 1000 tasks complete simultaneously)
Each message triggers DB operations (queries, updates)
No concurrency control - all messages processed concurrently
Connection pool exhaustion - DB connections max out
Event loop saturated - waiting on I/O operations

Message Burst (1000 messages)
    ↓
No Rate Limiting
    ↓
1000 concurrent async operations
    ↓
DB Connection Pool (max 50) exhausted
    ↓
949 operations waiting for connections
    ↓
Event Loop: Constantly polling/waiting
    ↓
CPU: 100% (context switching + polling overhead)

Why This Happens in Node.js

Unlike Java's thread pool model, Node.js uses a single-threaded event loop:

Java: Thread pool limits concurrent execution naturally (e.g., 50 threads = max 50 concurrent operations)
Node.js: No natural limit—can create unlimited Promises that all compete for the event loop

When Promises wait for I/O (DB connections), they don't "pause"—they constantly check if the resource is available, consuming CPU cycles.

The Missing Rate Limiting

Looking at our message queue configuration:

// config.prod.ts
config.messageQueue = {
  enableDefaultProducer: true,
  pub: { /* ... */ },
  // NO sub configuration! Consumer uses default settings
}

The subscriber has no concurrency control at either the:

Message queue level (no prefetch limit)
Application level (no semaphore/bottleneck)

Key Takeaways

Why Requests Hanging Cause CPU Spikes

Factor	Explanation
Promise overhead	Each pending Promise consumes event loop cycles
No timeout	Hanging requests accumulate indefinitely
Resource competition	DB connections, memory, file descriptors exhaust
Polling cost	Event loop constantly checks I/O readiness
Context switching	V8 engine overhead from Promise state transitions

Prevention Strategies

Always set timeouts for external calls (RPC, HTTP, DB)
Implement rate limiting for message consumers
Use Promise.allSettled instead of Promise.all to isolate failures
Monitor event loop lag as an early warning indicator
Add circuit breakers for cascading failure prevention

Monitoring Checklist

// Event loop lag monitoring
const eventLoopLag = require('event-loop-lag')
setInterval(() => {
  const lag = eventLoopLag()
  if (lag > 100) {  // > 100ms indicates problem
    console.warn(`Event loop lag: ${lag}ms`)
  }
}, 1000)

Conclusion

Node.js CPU spikes during request hanging are counterintuitive but explainable:

It's not the hanging itself that consumes CPU
It's the accumulation of waiting Promises competing for event loop attention
Timeout and concurrency control are essential defenses

The key insight: Node.js requires explicit resource management that other languages handle implicitly through thread pools. Without it, "doing nothing" can consume everything.

This article is based on real production incidents from a large-scale operation platform. The optimization reduced P99 latency from 60s to 8s and stabilized CPU usage at 40-50%.

References

The Node.js Event Loop — Node.js Documentation — Official documentation of the Node.js event loop
Don't Block the Event Loop — Node.js Guide — Official guide on avoiding event loop blocking
Understanding the Node.js Event Loop — YouTube (Bert Belder) — Deep dive into event loop internals from a Node.js core contributor

If you're interested in AI-assisted development workflows, check out my
AI Coding Playbook where I
cover tool selection and prompt templates.

I also wrote about building a personal knowledge base using Karpathy's
method which
covers how to organize technical learning into a publishing pipeline.

Felix Mao (毛毛星) | maoxunxing.com | @maoxunxing

Forem: Xunxing Mao

AI Coding Playbook: Tool Selection, Workflows, and Prompt Templates

Choosing AI Tools by Scenario

Common AI Tools

Cherry Studio Design Workflow

UI/UX Designer System Prompt Template

Core Questions for AI-Assisted Development

Prompt Template Library

Code Reading

Article / Note Organization

Book Report

Paper Reading

Codebase Improvement

High-Quality Answer Pre-check

Writing Style Switches

References

Related Reading

Node.js CPU Spike Analysis: When Requests Hang and Event Loop Starves

The Problem

Case 1: RPC Batch Processing - The Silent Killer

The Scenario

Why CPU Spikes When Requests Hang

The Solution

Results

Case 2: Message Queue Subscriber - The Rate Limiting Problem

The Scenario

Why CPU Spikes Without Rate Limiting

Why This Happens in Node.js

The Missing Rate Limiting

Recommended Solutions

1. Add Concurrency Control in Subscriber

2. Use p-limit for Simpler Control

3. Configure Message Queue Consumer Thread Pool

Key Takeaways

Why Requests Hanging Cause CPU Spikes

Prevention Strategies

Monitoring Checklist

Conclusion

References