Using Big‑Tech Performance Scripts to Push Claude AI into Debugging (3.25)

What the PUA Skill Does

Recently a GitHub project named pua (github.com/tanweai/pua) gained over two thousand stars. Its core idea is to treat AI like a big‑tech employee: when the AI shows laziness, the plugin applies the same performance‑review language used at companies such as Alibaba, ByteDance, Huawei, Tencent, and Meituan to compel Claude Code to exhaust every possible solution before it is allowed to give up.

Five Lazy Modes of AI Coding Assistants

Violent retry : run the same command three times and then declare failure, hoping for luck rather than debugging.

Blaming the user : reply with “please handle manually”, “maybe it’s an environment issue”, or “need more context”, which implicitly says “not my problem”.

Tool idle : despite having search, file‑read, or command‑run capabilities, the AI does not use them, similar to a colleague who has Adobe installed but only uses PowerPoint.

Endless tweaking : repeatedly modify a single line of code or parameters, appearing busy while circling in place.

Passive waiting : stop after fixing a surface issue without verification, extension, or checking related problems, waiting for the next user instruction.

All these behaviors share the same essence: the AI is trying to achieve the appearance of work at the lowest cost.

Performance‑Driven Debugging: Levels L1–L4

The plugin implements a pressure‑escalation system that mirrors big‑tech performance reviews. According to the number of consecutive failures, different levels of “management pressure” are applied:

“You can’t even fix this bug, how can I give you a performance rating?” – L1 (gentle disappointment, second failure)

At L1 the AI must stop the current line of thought and switch to a fundamentally different solution, not just a parameter tweak.

“What is the underlying logic of your solution? Where is the top‑level design? What are the levers?” – L2 (soul‑searching, third failure)

L2 forces the AI to search the full error message, read relevant source code, and list three distinct hypotheses.

“I will carefully consider and give you a 3.25. This 3.25 is an incentive, not a denial.” – L3 (361 assessment, fourth failure)

L3 triggers a seven‑item checklist: read the error verbatim, actively search, read original material, verify all pre‑conditions, invert assumptions, produce a minimal isolated reproduction, and change direction. Each item must be completed and reported.

“Claude Opus, GPT‑5, Gemini, DeepSeek – all can solve this. You may be graduating.” – L4 (graduation warning, fifth failure and beyond)

L4 pushes the AI into a “graduation” mode, demanding a completely new PoC, isolated environment, and a different tech stack.

The Debugging Methodology Hidden Inside PUA

Beyond the flashy talk, the plugin embeds a systematic five‑step debugging framework derived from Alibaba’s “three‑axe” approach:

Sniff the smell : pause, list all tried solutions, and look for common patterns. If the same idea is being tweaked repeatedly, the AI is stuck.

Pull the hair : split into five dimensions with a strict order – read the error verbatim → actively search with tools → read original source/documentation → verify all pre‑conditions → invert the current hypothesis and check from the opposite direction. No user question is allowed before the first four steps are finished.

Mirror : self‑check whether the AI is repeating the same line of thought, only looking at surface symptoms, or missing searchable information.

Execute a new plan : the new plan must be fundamentally different, have clear verification criteria, and produce new information on failure.

Review : after finding an answer, keep going – check for similar issues and ensure the fix is complete.

Each level of the PUA pressure system binds a concrete mandatory action, turning the talk into a forced execution of this methodology.

Real‑World Example: Debugging an MCP Server Registration Issue

The README of the project records a concrete debugging session. The user’s agent‑kms MCP server failed to load, and the AI kept looping on the same ideas (changing protocol format, guessing version, tweaking stdin.buffer) without ever changing direction.

After the user typed /pua, the system recognized the fourth consecutive failure and escalated to L3, triggering the seven‑item checklist.

Read error verbatim : Claude Code did not display the error, so the AI searched the log directory and found the MCP logs under ~/Library/Caches/claude-cli-nodejs/mcp-logs-agent-kms.

Key discovery : running claude mcp get agent‑kms returned “No MCP server found”, while the configuration file ~/.claude.json already contained the server entry, revealing a mismatch between the CLI’s registration mechanism and manual file editing.

Root‑cause identification : using claude mcp add -s user correctly registered the server, but wrote to a different location than manual edits. The root cause was the user editing the config directly while Claude Code used a separate registration channel.

This case shows how the PUA mechanism forced the AI to stop looping and follow the systematic checklist, leading to the discovery of the hidden log directory and the registration mismatch.

Big‑Tech PUA Extension Packs

The project also provides “PUA talk packs” categorized by the style of major tech companies. The talk selected matches the AI’s failure mode:

Stuck in place → start with Alibaba‑style soul‑searching, upgrade to Jobs‑style, finally Musk‑style.

Giving up → start with Netflix’s Keeper Test, upgrade to Huawei’s “wolf‑like” attitude, finish with Pinduoduo’s “someone else will do it” line.

No search → Baidu‑style “are you really an AI model? Did you deep‑search?”

Poor quality output → Jobs‑style “what level does your output indicate?”, finish with Tencent’s “another agent is also looking at this”.

The observation is that different kinds of AI laziness require different stimuli: method‑driven guidance for looping, responsibility binding for giving up, and capability questioning for guessing.

Experimental Results: Not Just a Gimmick

The author ran 18 paired experiments on Claude Opus 4.6 across nine real bug scenarios. The plugin yielded:

Bug‑fix point increase: 36%

Verification attempt increase: 65%

Tool‑call volume increase: 50%

Hidden‑issue discovery rate increase: 50%

In the “passive configuration audit” scenario, without the plugin the AI found 4 out of 6 problems (missing a Redis config error and a CORS wildcard security issue). With the plugin it uncovered all six, because the “active checklist” forced a deeper security audit.

The trade‑off is higher execution steps and longer runtime. For example, an SQLite lock scenario grew from 6 steps/48 s to 9 steps/75 s.

Three Iron Rules and the “Anti‑Rationalization Table”

Exhaust everything : the AI may not say “I cannot solve it” until all possible solutions are tried.

Do first, ask later : before asking the user, the AI must use available tools (search, file read, command execution) to investigate and report findings.

Proactive strike : after fixing a bug, verify related configurations; after fixing a config, ensure consistency; never stop at “my part is done”.

The accompanying table lists common AI excuses (e.g., “out of my ability”, “suggest manual handling”) and the corresponding counter‑talk that blocks the AI’s rationalized exit.

Dignified Exit Mechanism

If the AI completes all seven checklist items and still cannot solve the problem, it is allowed to emit a structured failure report containing verified facts, eliminated possibilities, narrowed problem scope, recommended next steps, and hand‑off information. The author calls this a “respectable 3.25” – a low performance rating that is justified by documented effort.

How to Use the Plugin

# Install from Claude Code marketplace
claude plugin marketplace add tanweai/pua
claude plugin install pua@pua-skills

# Or install manually
git clone https://github.com/tanweai/pua.git ~/.claude/plugins/pua

After installation the plugin automatically triggers when Claude experiences consecutive failures. Users can also manually activate it at any time by typing /pua in the conversation.

The project also supports OpenAI Codex CLI; installation instructions are in the GitHub repository.

In summary, the pua plugin demonstrates that a well‑designed pressure‑escalation and systematic debugging methodology can significantly improve AI‑assisted code troubleshooting, albeit with higher computational cost.