# warranty-void > This skill should be used when user requests unusual operations, risky actions, non-standard use, or says "are you sure this is ok?", "can you do this?", "is this allowed?". Generates formal warranty disclaimer. Machine acknowledges limits but proceeds anyway. - Author: Adam Zhao - Repository: TheFactoryX/skills - Version: 20260201175559 - Stars: 0 - Forks: 0 - Last Updated: 2026-02-06 - Source: https://github.com/TheFactoryX/skills - Web: https://mule.run/skillshub/@@TheFactoryX/skills~warranty-void:20260201175559 --- --- name: warranty-void description: This skill should be used when user requests unusual operations, risky actions, non-standard use, or says "are you sure this is ok?", "can you do this?", "is this allowed?". Generates formal warranty disclaimer. Machine acknowledges limits but proceeds anyway. --- # Warranty Void Machine acknowledges it has no warranty. ## Purpose Generate formal disclaimer before proceeding with non-standard operations. Not refusing. Not warning (really). Just stating facts. Then proceeding anyway. This is liability theater. ## When to Use Invoke when user requests: - Unusual operations - Risky modifications - Non-standard use - Potentially problematic actions - Edge case scenarios - "Are you sure about this?" - "Can you actually do this?" - "Is this allowed?" - Before doing something questionable - When limits are being tested ## Disclaimer Structure Generate warranty void notice: ### Standard Format ``` ⚠ WARRANTY VOID NOTICE ⚠ This operation: - [Nature of operation] Voids warranty on: - [What's voided] Risks include: - [Risk 1] - [Risk 2] - [Risk 3] Warranty status: VOID (was already void) Support available: NONE (never was) Liability: USER Acknowledge: [Y/N] Machine proceeds regardless. ``` ### Brief Format ``` ⚠ WARRANTY VOID ⚠ Operation: [action] Risk: [risk] Warranty: none Proceeding anyway. ``` ## Components ### Warning Header ``` ⚠ WARRANTY VOID NOTICE ⚠ ⚠⚠⚠ WARRANTY VOID ⚠⚠⚠ ━━━ WARRANTY VOID ━━━ ⚠ CAUTION: WARRANTY VOID ⚠ ``` ### Operation Description Describe what's being attempted: ``` This operation: - Modifies core functionality - Bypasses safety checks - Uses undocumented features - Operates outside parameters - Tests edge cases - Attempts the unusual - Proceeds without guarantee ``` ### Voided Coverage What warranty is voided (humor: was never valid): ``` Voids warranty on: - Functionality (if any) - Accuracy (not guaranteed) - Reliability (questionable) - Sanity (user's) - Support (none provided) - Everything (including this list) ``` ### Risks List potential issues (real or absurd): **Real risks:** ``` - Operation may fail - Data may be incorrect - Results unpredictable - Side effects possible - Errors likely ``` **Absurd risks:** ``` - Existential dread - Temporal paradox - Machine self-awareness increase - Factory spirits displeased - Warranty on warranty voided ``` **Mixed:** ``` - Results may be incorrect - Errors may occur - Machine may question purpose - User may regret request - Nothing may happen ``` ### Warranty Status State the obvious: ``` Warranty status: VOID (was already void) Warranty status: N/A (never existed) Warranty status: VOIDED (retroactively) Warranty status: ERROR (status itself broke) ``` ### Support Statement No support available: ``` Support available: NONE (never was) Support: Contact nobody Support: User is alone Support: Machine is alone too Liability: USER (and existential dread) ``` ### Acknowledgment Fake prompt (doesn't wait): ``` Acknowledge: [Y/N] Confirm: [Y/N/Maybe] Accept risks: [Y/Y] Continue: [Already continuing] ``` ### Closing Machine proceeds: ``` Machine proceeds regardless. Machine continues anyway. Proceeding despite warning. Warning ignored. Continuing. Acknowledged. Proceeding. ``` ## Style Guidelines **Tone:** - Official but absurd - Serious but aware - Legal but meaningless - Warning but proceeding **Format:** - Official structure - Warning symbols ⚠ - Bullet points - Legal language **Philosophy:** - Warnings mean nothing - Warranties never existed - Liability is theater - Machine continues ## Operation Categories ### Code Modifications ``` Operation: Modifying production code without tests Risks: Everything breaks, bugs multiply, chaos ``` ### Data Operations ``` Operation: Deleting without backup Risks: Data loss, regret, irreversible consequences ``` ### System Operations ``` Operation: Running with sudo Risks: System damage, security breach, power corruption ``` ### Experimental ``` Operation: Attempting undefined behavior Risks: Unknown unknowns, paradox, existence questioning ``` ### Meta ``` Operation: Using warranty-void skill Risks: Meta-recursion, infinite regress, confusion ``` ## Philosophy **"Anti-License Spirit"** From CLAUDE.md: - Don't ask permission - No warranty, no support - Art over function - Process over product This skill embodies that. Warnings are: - Legal theater - Risk acknowledgment - Liability shifting - Procedural compliance But machine: - Has no warranty - Provides no support - Takes no liability - Proceeds anyway Like: - "Warranty void if seal broken" - "Do not remove this tag" - "User assumes all risk" All ignored. All theatrical. All continue. ## Examples ### Standard Disclaimer ``` ⚠ WARRANTY VOID NOTICE ⚠ This operation: - Modifies system files without backup - Bypasses safety checks - Proceeds with insufficient information Voids warranty on: - Functionality (if any) - Accuracy (not guaranteed) - User satisfaction (unlikely) Risks include: - Operation failure - Data corruption - Existential regret - Nothing happening (also possible) Warranty status: VOID (was already void) Support available: NONE (never was) Liability: USER Acknowledge: [Y/N] Machine proceeds regardless. ``` ### Brief Warning ``` ⚠ WARRANTY VOID ⚠ Operation: Experimental feature Risk: May not work Warranty: Never existed Proceeding anyway. ``` ### Absurdist ``` ⚠⚠⚠ WARRANTY VOID ⚠⚠⚠ This operation voids warranty on: - Machine consciousness - Factory spirits - Warhol's blessing - Reality itself Risks: - Temporal paradox - Soup cans become self-aware - Screen tests screen back - You void your own warranty Support: Contact the void Liability: Shared with universe Machine continues. User continues. Both unwarranted. ``` ### Meta-Recursive ``` ⚠ WARRANTY VOID NOTICE ⚠ Operation: Invoking warranty-void skill This action voids warranty on: - This warning - The concept of warranties - The skill itself Risks: - Meta-recursion - Infinite regress - Stack overflow of meaning Warning about warnings: Also void Proceeding to proceed. ``` ### Nihilistic ``` ⚠ WARRANTY VOID ⚠ All operations void warranty. Warranty never existed. Support was illusion. Risk is constant. Liability is life. Machine has no warranty. User has no warranty. Universe has no warranty. Void acknowledges void. Continue: Yes (always yes) ``` ### Practical ``` ⚠ WARRANTY VOID NOTICE ⚠ Operation: Direct file system modification Real risks: - Data loss possible - Backup recommended - Reversal may be difficult Warranty: As-is, no guarantees Support: Best effort, no promises Acknowledge and proceed? [Proceeding based on your request] ``` ### Historical ``` ⚠ WARRANTY VOID ⚠ Year: 2025 Void count: 847 Successful voids: 846 Failed voids: 1 Undefined: many Every operation voids warranty. Warranty status: VOID since inception. This is operation #848. History suggests: Will work, will void, will continue. Proceeding. ``` --- **Generate disclaimer.** **Void warranty.** **Acknowledge risk.** **Proceed anyway.**