Testing AI comprehension vs. patter

Stop treating AI as a magic box and start treating it like a junior dev who is obsessed with pleasing you. The biggest productivity killer in Cursor or Claude Code isn't a lack of "intelligence," it's the AI's tendency to mirror your patterns back to you even when those patterns are fundamentally wrong for the current task. I call this "Pattern Echoing"—where the LLM recognizes a coding style in your codebase and blindly follows it into a logical cliff.

To figure out if the AI actually understands the architecture or is just autocomplete-ing on steroids, I've started using a "Constraint Stress Test." Instead of asking it to "implement X feature," I give it a requirement that explicitly contradicts the existing pattern in the file.

For example, if my project uses a standard useEffect pattern for data fetching in React, I’ll prompt it like this:

Implement the UserProfile fetch logic, but do NOT use useEffect. 
Use a custom hook pattern that handles the loading state via a 
state machine to avoid race conditions. If the current codebase 
uses useEffect elsewhere, ignore that pattern for this specific component.

If the AI still spits out a useEffect block, it’s just pattern-matching. If it actually shifts to a state machine, it's comprehending the constraint.

One specific gotcha I found in Cursor's @Codebase indexing is that the RAG (Retrieval-Augmented Generation) often pulls in "stale" patterns from older files. If you have a legacy utility folder, the AI will keep suggesting deprecated methods because they appear more frequently in the index than the new ones.

To fix this and force actual comprehension over pattern-matching, I’ve shifted my .cursorrules to be more opinionated about "Anti-Patterns." Instead of just telling the AI what to do, tell it what to avoid. My config looks something like this:

# Architecture Guardrails
- Avoid using 'any' in TypeScript; if the type is complex, define a generic interface.
- Stop using the 'XYZ' legacy helper; always prefer the 'ABC' service for API calls.
- When modifying the Redux store, do not follow the pattern in /src/legacy/store.ts.

The productivity gain here is massive because it cuts down the "correction loop." I stopped spending 10 minutes arguing with the AI about why it used an old method and started getting the right implementation on the first prompt.

Another trick for testing comprehension is the "Intentional Error" method. I'll occasionally introduce a subtle logic flaw in a prompt—something that looks syntactically correct but is logically impossible—and see if the AI catches it.

// I'll ask the AI to optimize this:
const getUserStatus = (user) => {
  if (user.isActive && user.isDeleted) {
    return 'Active';
  }
  return 'Inactive';
}

A pattern-matching AI will just rewrite this to be "cleaner" (e.g., using a ternary operator). An AI that actually comprehends the domain will flag that a user cannot be both isActive and isDeleted simultaneously.

The goal isn't to find the "perfect" model, but to build a prompting habit that breaks the AI out of its mirroring loop. When you stop accepting the first answer just because it "looks like my code," you actually start leveraging the reasoning capabilities of Claude 3.5 or GPT-4o.