Editing Openai/691a14bb-ac48-8008-85d0-2e4fb3f780d1 (section)

=== Assistant: Switch to Claude Opus 4.1 Thinking for root-cause debugging. ===
Switch to Claude Opus 4.1 Thinking for root-cause debugging. It’s the best in your list at error localization and explaining failure chains across client → API → DB.

If that stalls, use this fallback order by scenario:
* Repo-wide or multi-file symptoms: Kimi K2. Very large context. Good for dumping logs, configs, and many files at once.
* Commit/diff-aware inspection or structured refactors: SWE-1.5. Strong on repo semantics and grouping related changes.
* Protocol/API or request/response anomalies (cookies, CSRF, caching, 4xx/5xx): Gemini 2.5 Pro. Good at HTTP traces and JSON/state reasoning.
* Logic/constraints bugs (validation, race conditions, invariants): o3 (high reasoning). Precise stepwise reasoning.
* Test scaffolding to reproduce the bug fast: Qwen3-Coder Fast. Generates focused unit/integration tests quickly.
* Pure code-search/boilerplate checks: GPT-5-Codex. Fast at locating misused APIs and writing minimal patches.

Minimal anti-looping prompt to give the chosen model:

<syntaxhighlight>Goal: Settings in Admin Console do not persist.

Context: [paste failing request log lines, server error excerpts, relevant files: handler, DTO/serializer, DB layer, cache, CSRF/config].

Constraints:
* Produce a 6-step investigation plan first.
* For each step, name the observable you need (log line, request/response diff, DB write result).
* After each hypothesis, show falsifying evidence or confirm with an artifact.
* No repeating prior steps. Each attempt must add a new hypothesis or new evidence.
* Output must include: (a) minimal repro, (b) failing request example, (c) patch or config diff, (d) verification command.

</syntaxhighlight>

High-leverage checks for “settings not persisting” you can paste as tasks:
# Client → API: Capture one save attempt with full request/response. Confirm 200/204 vs hidden 401/403/409/422. Check CSRF token, Content-Type, SameSite, CORS, and ETag/precondition headers.
# Server handler: Verify route method matches client. Confirm body parsing and schema validation; log rejected fields.
# Write path: Ensure transaction commits. Check ORM autocommit, await on async saves, and error swallowing.
# Caching layer: Confirm cache write-through/invalidations. Look for stale reads after write.
# Permissions: Verify feature flags/tenant filters. A missing tenant scope often reads the old row.
# Serialization: Make sure returned payload echoes new values; mismatch implies write succeeded but read path differs.

Pick model by the bottleneck:
* Need deep causal trace → Claude Opus 4.1 Thinking.
* Need huge context of files/logs → Kimi K2.
* Need repo-structured fixes/commits → SWE-1.5.
* Need HTTP/state scrutiny → Gemini 2.5 Pro.
* Need invariant math-like reasoning → o3 high reasoning.
* Need fast tests → Qwen3-Coder Fast.