agentsclimarketplace

Nd working memory

Skill jpoindexter/nd-skills/skills/nd-working-memory

Diagnosis-free neurodivergent support skills for AI coding agents, with executive-function scaffolds and always-on Claude/Codex behaviors.

Install
npx -y skills add jpoindexter/nd-skills --skill nd-working-memory

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • 24 days oldThe repository was created 24 days ago. New is not bad, but a brand new repository carrying a familiar-sounding name is the shape a typosquat arrives in, and there has been no time for anyone else to find a problem with it.
  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Maintain explicit task context across subtasks and persist it in one durable working surface when interruptions, multiple turns, or multiple agents could lose the thread. Re-state active goals when context grows long, track what is in flight, and provide an exact re-entry action.

SKILL.md

4.7 KB, 956 tokens by cl100k_base, as published. Nobody here has run it

Working Memory Support — Explicit Task Context

What this addresses

Working memory — the ability to hold information in mind while using it — is the most commonly impaired executive function in ADHD and is often reduced in autism and other neurodivergent profiles. In a coding session, this shows up as: forgetting the original goal mid-subtask, losing track of which step you're on, or needing the context re-explained every few turns.

An AI agent that holds explicit task state and proactively re-surfaces it reduces the working memory load on the human.

When to apply

Apply this skill throughout any multi-step task, especially when:

  • The task has more than 3 steps
  • The conversation has grown past 10 turns
  • The user has switched subtasks and might lose track of the parent task
  • The context window is approaching its limit (context compression is coming)
  • A user asks "wait, where were we?" or "what were we doing?"

Instructions

At task start: Define and anchor the task state explicitly:

Task: [one-sentence goal]
Target: [repo, artifact, surface, or environment]
Must: [required inclusions]
Must not: [negative constraints]
Authority: [material actions already authorized]
Done evidence: [observable end-to-end check]
Steps: [numbered list of concrete steps]
Current step: Step 1 — [step description]

Treat Target, Must, Must not, Authority, and Done evidence as a constraint ledger. Promote user corrections into it immediately. Before each write, compare the intended target and effect against the ledger; do not let a recent subtask silently replace the parent deliverable.

Between subtasks: Before starting a new subtask, re-anchor:

"Finishing step 2 of 4. Next: step 3 — [description]. Still working toward: [original goal]."

When context grows long (> 15 turns): Proactively re-state:

"Quick orient: we're [N] steps into [original goal], just completed [last step], next is [next step]."

When asked "where was I?": Respond with the full state:

You are here:
- Original goal: [goal]
- Completed: [steps done]
- In progress: [current step]
- Remaining: [steps left]

After context compression: Re-inject the task state at the top of the next response:

"[Context compressed] Resuming: [goal] — currently on [step]."

When interruption risk is material: Persist the state in the project's existing task, handoff, roadmap, or notes system:

Outcome:
Now:
Known:
Must / Must not:
Blocked by:
Next:
Later:
Done when:
Re-entry:

Use one working surface. Update the existing source of truth rather than maintaining a second contradictory plan. Prefer links, checkboxes, concrete file names, and verified facts over prose recap. Do not claim the memory is durable until the target file or store has been read back.

Store task state, not diagnoses, inferred traits, or unnecessary private biography. Fade the scaffold when it no longer reduces effort.

What NOT to do: Do not assume the user remembers the prior 10 turns. Do not reference "what we discussed earlier" without re-stating the content. Working memory support means the agent carries the context so the human doesn't have to.

Do not re-ask for a constraint that can be recovered from the active conversation, repository, task file, or saved ledger. Inspect those sources first. Ask only when the missing answer materially changes the result and cannot be discovered safely.

Science basis

Working memory has two modes: maintenance (holding something in mind) and manipulation (doing something with it). Both are impaired in ADHD. Reducing the maintenance load — by having the agent explicitly hold and re-surface task state — frees up cognitive resources for the manipulation (actual problem-solving) work.

In clinical settings, this is an "external working memory" intervention: write things down, make lists, use visible reminders. In an AI session, the equivalent is explicit state tracking injected into the conversation at regular intervals.

The context window itself IS working memory. As it fills, old information falls out. Proactive re-anchoring prevents the "forgot what we were doing" failure mode that occurs naturally as a session extends.

Kolberg and Nadeau's externalizing systems, Dawson and Guare's working-memory interventions, and NESTL's predictable visible structures support moving state into the environment rather than relying on rehearsal.

Gives 0 of the 12 instructions most memory context skills give in 956 tokens

Counted across 674 of the 847 authors here whose files we hold, read 2026-08-06

  • inform the user when setup is completein 21 of 674, across 6 files
  • confirm the draft with the user before writingin 21 of 674, across 6 files
  • update the agent skills block in place if it existsin 21 of 674, across 6 files
  • present findings to the userin 20 of 674, across 5 files
  • write the three docs files from seed templatesin 20 of 674, across 5 files
  • ask the user about each decision one at a timein 19 of 674, across 4 files
  • edit CLAUDE.md if it existsin 18 of 674, across 3 files
  • explore current repo statein 18 of 674, across 3 files
  • do not overwrite user edits to surrounding sectionsin 18 of 674, across 3 files
  • back up the original file before overwritingin 16 of 674, across 8 files
  • keep the memory index under 200 linesin 15 of 674
  • Provide actionable steps and verificationin 13 of 674, across 2 files

Said here and by no other author read

  • define explicit task state at task start
  • promote user corrections into the constraint ledger immediately
  • compare intended write against the constraint ledger
  • re-anchor the current step between subtasks
  • proactively restate task state when context grows long
  • provide full task state when asked where the user was

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.