Advanced Strategies

Instead of asking AI to be a generic "senior developer," assign it specific expert personas for different tasks. Different perspectives surface different insights — the same way a team of specialists outperforms a single generalist.

Step 1 — As a React performance expert:
Analyze this component for unnecessary re-renders and
expensive computations.

Step 2 — As a security auditor:
Review the same code for vulnerabilities and data exposure.

Step 3 — As a UX engineer:
Evaluate the user-facing behavior. Are there edge cases
that would confuse users?

Step 4 — Synthesize all three perspectives into a
prioritized list of improvements.

Each persona activates a different "lens" in AI's analysis. A performance expert focuses on rendering cycles and memoization. A security auditor looks for input validation and data leaks. A UX engineer thinks about user behavior and error states. The synthesis step combines all three into actionable priorities.

For complex problems, don't ask AI for the answer directly. Instead, ask it to reason through the problem step by step. This produces dramatically better results for anything involving multiple decisions or trade-offs.

I need to add real-time collaboration to the family planner.

Before proposing a solution, think through these steps:

1. What are the technical options? (WebSocket, SSE, polling)
2. What are the trade-offs of each for my use case?
3. What's the simplest option that handles 10 concurrent users?
4. What changes to my current architecture are needed?
5. What are the main risks or failure modes?

Show your reasoning for each step, then give your
recommendation with justification.

Explicit reasoning chains force AI to think before answering. Without this structure, AI jumps to the first plausible solution. With it, AI explores the problem space systematically and arrives at better-justified conclusions.

After AI generates code, ask it to attack its own output. This technique consistently finds issues that a standard "review this code" prompt misses.

You just wrote this code. Now switch roles.

You are a hostile code reviewer whose job is to find
every possible issue. Be ruthless. Look for:

- Bugs that would only appear under unusual conditions
- Performance problems that emerge at scale
- Security vulnerabilities an attacker could exploit
- Assumptions that might not hold in production
- Race conditions or timing issues

Don't be diplomatic. List every problem you can find.

The instruction "don't be diplomatic" is important. AI has a tendency to be polite about its own output, hedging criticism with "this is mostly fine but..." Forcing a hostile stance produces far more thorough analysis.

Instead of asking for the final complex version immediately, build complexity incrementally. Each stage adds one layer of sophistication, and you verify correctness at each level.

Build a data table component. We'll add complexity in stages.

Stage 1: Static table that renders an array of objects.
         Just rows and columns, nothing else.

Stage 2: Add sorting (click column headers to sort).

Stage 3: Add filtering (search input that filters rows).

Stage 4: Add pagination (10 rows per page with controls).

Stage 5: Add row selection with checkboxes.

Start with Stage 1 only. I'll tell you when to proceed.

This strategy prevents the "complexity explosion" where AI tries to build everything at once and produces tangled code. Each stage is simple, testable, and builds cleanly on the previous one. By stage 5, you have a sophisticated component with a clean architecture.

Instead of asking "what's the best way to do X," ask AI to compare multiple approaches with explicit criteria. This produces richer analysis and better-justified decisions.

Compare these three state management approaches for my app:

1. React useState + context
2. Zustand
3. Redux Toolkit

Evaluate each on these dimensions:
- Learning curve (for a mid-level React developer)
- Bundle size impact
- Boilerplate required
- DevTools quality
- Suitability for my app size (~15 components, ~5 data entities)

Present as a comparison, then recommend one with reasoning.

The explicit evaluation dimensions prevent AI from defaulting to the most popular option. It forces genuine analysis across criteria that matter for your specific situation.

Traditional rubber duck debugging works by forcing you to explain the problem out loud. AI takes this further — it actually responds, asks clarifying questions, and proposes hypotheses.

I'm stuck on a problem and need to think it through.

Situation: My activity filter works for single-member
selection but breaks with multi-select. The filtered
list shows the right count but the wrong activities.

I've checked:
- The filter function logic (seems correct)
- The state updates (members array updates correctly)
- The component re-renders (it does)

Something is wrong but I can't see what.

Ask me questions to help me narrow down the issue.
Don't guess the answer — help me find it myself.

The instruction "help me find it myself" is key. It tells AI to ask diagnostic questions rather than jumping to solutions. This approach builds your own debugging skills while leveraging AI's ability to ask the right questions — questions you might not think to ask yourself.

Treat your best prompts like code: save them, version them, and reuse them. Over time, you build a personal library of high-quality prompts that consistently produce excellent results.

A prompt library isn't just a convenience — it's a compound advantage. Each time you refine a prompt, every future use benefits. After six months, your library of battle-tested prompts gives you consistently better output than someone writing prompts from scratch every time.