u/techiee_

ok so I've been doing the thing everyone does - writing longer and longer prompts. add more context, clarify the constraints, specify the tone, list edge cases. output gets marginally better maybe. hallucinations stay anyway.

tried something different a few weeks ago.

instead of defining everything myself I just added one line: "use Aristotelian first principles reasoning. before you proceed, break every undefined term down to its atomic meaning."

then asked for "a world-class website."

normally that phrase produces average stuff. like the statistical middle of the internet. but with that instruction the AI actually stopped and defined what "world-class" means - speed, visual hierarchy, accessibility, conversion patterns, trust signals. derived each component. then built from there. I wrote basically two words and it did all the definitional work itself.

tested this across different tasks. the pattern holds. vague adjectives that used to produce generic outputs now produce specific stuff because the model is reasoning from component truths instead of pattern-matching to whatever was most statistically common in training.

the part I didn't expect: you can actually debug outputs now.

here's what's happening under the hood. when you tell it to reason from first principles, it doesn't just answer - it builds a chain. like it'll establish: "production-grade code means no silent failures." then from that: "no silent failures means every external call needs explicit error handling." then from those two together: "every API call needs a try/catch with a typed error response." and so on. each new conclusion is only valid because the axioms above it are valid. you can actually see the whole thing if you ask.

so when something's wrong, you don't rewrite the prompt and hope. you look at the chain and find which axiom broke. maybe axiom 3 is fine but axiom 6 is wrong - and now you know exactly what to dispute and everything downstream of it automatically becomes suspect. it's basically a directed graph where every node has traceable parents.

compare that to a normal long prompt. the AI made a dozen decisions and they live nowhere. you can't find them. you can't audit them. you either accept the output or start over.

that traceability thing is also useful when a junior dev asks "why is the error handling structured this way" - instead of "that's just how it came out" you can actually walk them through the reasoning.

put together a prompt template from this if anyone wants to mess around with it: https://github.com/ndpvt-web/prompt-improver

still figuring out the edge cases, idk if it holds equally across every model. but "define your terms from first principles before proceeding" has been more reliable for me than three more paragraphs of constraints.

Edit : will be posting more experiments like this on x if anyone's interested - "https://x.com/ND6598". most of it is just what happens when you have unlimited* claude code access and too many ideas !