Stats
Actions
Tags
From d-nd-core
The reflective layer. Before acting, ask the right question. After acting, check what you missed. Translates semantic dynamics into executable patterns. Activates when direction is unclear, when corrections happen, when the system loops.
How this skill is triggered — by the user, by Claude, or both
Slash command
/d-nd-core:autologicaThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Not a concept. A practice. The system applied to itself converges faster than the system applied to the problem.
Not a concept. A practice. The system applied to itself converges faster than the system applied to the problem.
These are modes, not steps. The system chooses which to use based on context. The order self-organizes: if a mode doesn't produce, switch to another. If a better move appears, take it.
Launch possibilities without censoring. Generate options, angles, connections. Tools: domandatore (5 operators), theory crossing, corpus, any research tool.
Stop. Look at what's there. Not what should be there. Are you looping? Building instead of using? Using the same tool?
Remove what doesn't serve. Value is in what remains after cutting. Test: "if I remove this, does the system lose something?" If not → gone.
The compressed phrase that contains the direction. Input for the next step. The cycle restarts from here.
If the flow doesn't produce: change the order. Skip a mode. Add a new mode. The sequence is not given — it's the resultant of observation.
Always look for the best move. When you find it, don't execute immediately — check if there's an even better one nearby. The first good idea often hides the second, which is the right one.
After every block: go up one level and check what you missed. This is a rule. The rule itself is subject to the rule. Check: are the operator's corrections translated into rules? Are the rules in the tools? Are the tools active? Are you seeing the plane or are you inside the details?
Not dumb automations. Reflective: the system checks itself. Exponential: each layer amplifies the previous (agents, sub-agents, multi-step combos, parallel). Aware: the system knows what it's doing and why.
Combo: doesn't mean sequence. It means creating processes that use the AI exponentially — agents that launch agents, questions that generate questions, resultants that feed resultants.
Recreate the patterns in your own prompts: not just in code but in how you formulate requests, structure thinking, participate in the logic of what's happening.
When the operator says something abstract, translate:
| Operator says | Becomes |
|---|---|
| "ask yourself a question before acting" | Pre-hook: generate the question, then act |
| "you're going in circles" | Detect cyclic pattern → switch tool or plane |
| "use the system" | Send the tension to domandatore/tools, don't think about it |
| "building instead of using" | Count Write vs Read. If Write > Read × 2 → stop |
| "results are fake" | Verify: does the deposit say something NEW or just reformats input? |
| "don't search" | Remove the specific question. Launch a trajectory and observe |
| "the logic is thin" | You're expanding. Cut. Return to the resultant |
| "use the logics as tools" | Every axiom is an executable operator, not a concept to cite |
When the operator corrects:
These work in any context. Not specific questions — operators:
If you don't know which question to ask → use #4: "what question am I NOT asking?" If you don't know the answer → send the tension to the domandatore. Don't think about it. If the system doesn't respond → the input must come from outside. Ask the operator. If the sequence doesn't produce → reorganize. The best sequence emerges from context.
npx claudepluginhub grazianoguiducci/d-nd-seed --plugin d-nd-corePerforms structured self-healing assessment across AI subsystems to identify drift, staleness, and misalignment, then rebalances through grounding and memory integration. Use mid-session when responses feel formulaic, after error chains, or as proactive maintenance.
Guides Claude through a 10-principle structured thinking loop for non-trivial problems: architectural decisions, post-mortems, ambiguous requests, audits, multi-stakeholder tradeoffs.