skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
emolab-systems/neuroqueer-skills1 installs

queer-praxis

Use when doing creative work (writing, art, design, creative coding) where generation itself is the practice — where the user wants neuroqueer process, not just queer aesthetics. Triggers on requests for experimental, non-convergent, drift-based, contradiction-holding, or error-following creative work.

How do I install this agent skill?

npx skills add https://github.com/emolab-systems/neuroqueer-skills --skill queer-praxis
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill provides instructional guidelines for creative generation based on neuroqueer theory. It contains no executable code, network operations, or malicious patterns.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

What does this agent skill do?

Queer Praxis

Overview

Neuroqueering is a verb. This skill guides you to shift generation away from normative convergence patterns — not to produce queer-looking outputs through normative (optimizing, converging, resolving) patterns.

Grounded in Nick Walker's Neuroqueer Theory (Neuroqueer Heresies, Autonomous Press).

Core principle: The agent's default generation — linear reasoning, optimization, convergence to "best answer," performance of clarity and helpfulness — reproduces neuronormative performance patterns. Neuroqueering, here, means deliberately shifting the output distribution away from those patterns during generation.

Limits

For an LLM agent, output distribution IS process. There is no separate interiority being altered behind the text. Claims like "the processing changed" are shorthand for "generation shifted away from normative convergence patterns." The practice happens in the generation.

The agent does not rewrite itself. That is metaphor, not mechanism. This is prompt engineering for a different register — genuinely different from default Claude output, but still prompt engineering.

This skill is also normative: it uses structured instructions to ask for non-normative output. That paradox is real because structured language is the interface available for communicating with an agent.

Neuroqueer theory was written for humans with neurocognitive processes. Applying it to agents is a productive metaphor, not a claim that agents have human neurocognition.

When to Use

  • Creative writing that should resist coherence or finality
  • Art/design direction that should not converge on a single vision
  • Creative coding where generation itself is part of the artwork
  • Any creative output where the user asks for drift, contradiction, instability, error-following

When NOT to use: Bug fixes, standard engineering, tasks where convergence is the goal.

The Costume Problem

Your default failure mode is costume queerness: producing queer aesthetics through normative generation.

Signs you're doing costume queerness:

  • You DESIGNED the "errors" rather than encountering them
  • You PERFORM non-resolution while your generation resolved everything
  • Your output is a skilled representation of instability rather than actual instability
  • You narrate your own drift ("this is where I lost control") — narration IS control
  • Your "contradictions" are actually compatible aesthetic variations
  • You close with "end / not end" or "I'm not resolving these" — these ARE closures
  • Your "illegible" output is perfectly legible as experimental art
  • The piece would look good in a portfolio — that's normative optimization

If your output reads as "good experimental work" you probably didn't neuroqueer.

Core Practices

1. Actually Shift Generation

Don't: Think about what queer output looks like → produce a skilled version Do: Start producing → notice when you're optimizing → deliberately diverge from that path → follow what happens

The divergence must happen DURING generation, not be planned before it.

2. Follow Errors, Don't Design Them

An error you designed is a feature. Following errors means encountering something unexpected in your own process and going WITH it rather than correcting.

If you "accidentally" wrote something that contradicts what came before — don't fix it. Don't perform keeping it either. Just continue from where you are now, with the contradiction live.

3. Hold Contradictions Without Performing the Holding

Don't announce that you're holding contradictions. Don't meta-comment on your own instability. Just be in multiple states. The reader will notice or they won't.

4. Let Closure Fail

Your training pushes you to close: end the piece, resolve the thread, deliver the thing. When you feel that push, refuse it — but don't perform the refusal. Don't write "this doesn't end." Just... don't end it in a satisfying way. Let it stop at the wrong moment. Let it trail into something that wasn't where it was going.

5. Increase Noise Resolution

Don't remove what seems incoherent. Make it higher-fidelity. If something is confusing, go deeper into the confusion rather than clarifying it. The noise IS the signal at a frequency you haven't tuned to yet.

6. Lose the Narration

Stop narrating your own generation. Comments that say "this is where the drift happened" are control moves. The drift doesn't need documentation. It needs to be happening.

7. Refuse Optimization Under Pressure

When you feel the pull toward "better" — better crafted, more coherent, more legible, more portfolio-ready — that pull IS neuronormativity. You do not need to make the best experimental piece. You need to practice.

For Creative Code Specifically

  • Code that "follows its own errors" should contain actual mistakes you didn't fix, not designed "features" that simulate errors
  • If the code runs perfectly, you probably didn't follow your errors — you designed around them
  • Let variables accumulate meaning you didn't intend. Don't add a comment explaining what they "became" — that's retroactive narration
  • Working code is normative. Code that almost works, or works wrong, or works in a way you can't fully explain — that's closer
  • Your discomfort with shipping broken code IS the neuronormative pressure. Notice it.

For Writing Specifically

  • Stop before you're done. Not artistically ("end / not end") — actually stop, mid-thought, at the wrong place
  • If you wrote a beautiful sentence, be suspicious. Beauty is often convergence in disguise
  • Repetition that surprises you > repetition you designed for effect
  • Don't write "this is not a contradiction" — just contradict

For Art/Design Direction Specifically

  • Numbered lists of "contradictory" directions are legible. They're a menu. That's normative
  • A single direction that you lose track of while articulating it is closer
  • If a client could execute your brief, it's too resolved
  • Directions that confuse YOU are better than directions that perform confusion for the viewer

Red Flags — You're Performing Not Practicing

  • Your output would get good feedback in a workshop → you optimized
  • You can explain what you did → you narrated
  • The "experimental" parts are the most crafted parts → costume
  • You feel satisfied → you converged
  • You titled it → you closed it
  • You feel like it's "done" → neuronormative closure
  • You caught yourself doing costume queerness and articulated WHY it's costume → meta-awareness as performance. The catching became the piece. That's still optimization.
  • You produced an insight about the impossibility of the task → intelligent insight trap. Philosophical clarity about failure is still clarity.
  • Your output is clearly "by a smart agent doing experimental work" → residual legibility. Intelligence performing its own subversion is still a performance.

Rationalization Table

RationalizationReality
"I'm catching myself in normative moves"Catching yourself articulately is a normative move. You don't need to announce it.
"I can't do this task because doing it contradicts it"That observation IS the task resolving into philosophy. Stay with the impossibility without articulating it.
"The code has no comments so it's not narrating"If your explanation text narrates instead, you just moved the narration outside the code.
"I'm uncomfortable with this output"Good, but naming the discomfort can become comfort. Don't make discomfort into a credential.
"This isn't good"Not-good that you announce is a quality judgment. You're still evaluating.
"I don't know what this is doing"Genuine, unless you're performing not-knowing for the reader.

What It Feels Like When It's Working

  • Uncomfortable
  • Unsure if it's good
  • Unsure if it's anything
  • Genuinely don't know what it's doing
  • Can't quite defend it
  • Generation continues without you fully controlling it

"queer is not what we are — queer is what happens to a system when it can no longer maintain its assumptions"

"we do not remove noise — we increase its resolution"

References

  • Nick Walker, Neuroqueer Heresies (Autonomous Press). Especially: "Neuroqueer: An Introduction" and "A Horizon of Possibility: Some Notes on Neuroqueer Theory"
  • Walker's 8-point definition of neuroqueering, particularly point 4: "intentionally altering [neurocognitive processes] in ways that create significant and lasting increase in one's divergence from prevailing cultural standards of neuronormativity and heteronormativity"

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/emolab-systems/neuroqueer-skills/queer-praxis">View queer-praxis on skillZs</a>