agenticnotetaking
84 verified skills76,967 total stars
reseed
Re-derive your knowledge system from first principles when structural drift accumulates. Analyzes dimension incoherence, vocabulary mismatch, boundary dissolution, and template divergence. Preserves all content while restructuring architecture.
testing2,871
tasks
View and manage the task stack and processing queue. Shows pending work, active tasks, completed items, and queue state. Triggers on "/tasks", "show tasks", "what's pending", "task list", "queue status".
tools2,871
reflect
Find connections between notes and update MOCs. Requires semantic judgment to identify genuine relationships. Use after /reduce creates notes, when exploring connections, or when a topic needs synthesis. Triggers on "/reflect", "/reflect [note]", "find connections", "update MOCs", "connect these notes".
tools2,871
architect
Research-backed evolution advice for your knowledge system. Analyzes health reports, friction patterns, and derivation history to propose specific changes with research justification. Never auto-implements — proposals require your approval.
testing2,871
upgrade
Apply plugin knowledge base updates to an existing generated system. Consults the Ars Contexta research graph for methodology improvements, proposes skill upgrades with research justification. Never auto-implements. Triggers on "/upgrade", "upgrade skills", "check for improvements", "update methodology".
tools2,871
verify
Combined verification — recite (description quality via cold-read prediction) + validate (schema compliance) + review (health checks). Use as a quality gate after creating notes or as periodic maintenance. Triggers on "/verify", "/verify [note]", "verify note quality", "check note health".
testing2,871
reweave
Update old notes with new connections. The backward pass that /reflect doesn't do. Revisit existing notes that predate newer related content, add connections, sharpen claims, consider splits. Triggers on "/reweave", "/reweave [note]", "update old notes", "backward connections", "revisit notes".
data-ai2,871
add-domain
Add a new knowledge domain to your existing system. Derives domain-specific configuration through conversation, generates domain folders, templates, and vocabulary while preserving and connecting to your existing architecture.
testing2,871
health
Run condition-based vault health diagnostics. 8 categories — schema compliance, orphan detection, link health, description quality, three-space boundaries, processing throughput, stale notes, MOC coherence. 3 modes — quick (schema+orphans+links), full (all 8), three-space (boundary violations only). Returns actionable FAIL/WARN/PASS report with specific fixes ranked by impact. Triggers on "/health", "check vault health", "maintenance report", "what needs fixing".
development2,871
setup
Scaffold a complete knowledge system. Detects platform, conducts conversation, derives configuration, generates everything. Validates against 15 kernel primitives. Triggers on "/setup", "/setup --advanced", "set up my knowledge system", "create my vault".
testing2,871
recommend
Get research-backed architecture advice for your knowledge system. Describe your use case, constraints, and goals — get specific recommendations grounded in TFT research with rationale for each decision. Triggers on "/recommend", "what would you recommend", "architecture advice", "knowledge system for".
development2,871
help
Contextual guidance and command discovery. Three modes — narrative (first-time), contextual (mid-task), compact (quick reference). Shows available commands, active skills, and intelligent suggestions based on vault state. Triggers on "/help", "what can I do", "show commands", "how does this work".
data-ai2,871
ask
Query the bundled research knowledge graph for methodology guidance. Routes questions through a 3-tier knowledge base — WHY (research claims), HOW (guidance docs), WHAT IT LOOKS LIKE (domain examples) — plus structured reference documents. Returns research-backed answers grounded in specific claims with practical application to the user's system. Triggers on "/ask", "/ask [question]", "why does my system...", "how should I...".
testing2,871
validate
Schema validation for notes. Checks against domain-specific templates. Validates required fields, enum values, description quality, and link health. Non-blocking — warns but doesn't prevent capture. Triggers on "/validate", "/validate [note]", "check schema", "validate note", "validate all".
testing2,871
graph
Interactive knowledge graph analysis. Routes natural language questions to graph scripts, interprets results in domain vocabulary, and suggests concrete actions. Triggers on "/graph", "/graph health", "/graph triangles", "find synthesis opportunities", "graph analysis".
data-ai2,871
seed
Add a source file to the processing queue. Checks for duplicates, creates archive folder, moves source from inbox, creates extract task, and updates queue. Triggers on "/seed", "/seed [file]", "queue this for processing".
testing2,871
learn
Research a topic and grow your knowledge graph. Uses Exa deep researcher, web search, or basic search to investigate topics, files results with full provenance, and chains to processing pipeline. Triggers on "/learn", "/learn [topic]", "research this", "find out about".
development2,871
remember
Capture friction as methodology notes. Three modes — explicit description, contextual (review recent corrections), session mining (scan transcripts for patterns). Triggers on "/remember", "/remember [description]".
testing2,871
reduce
Extract structured knowledge from source material. Comprehensive extraction is the default — every insight that serves the domain gets extracted. For domain-relevant sources, skip rate must be below 10%. Zero extraction from a domain-relevant source is a BUG. Triggers on "/reduce", "/reduce [file]", "extract insights", "mine this", "process this".
data-ai2,871
next
Surface the most valuable next action by combining task stack, queue state, inbox pressure, health, and goals. Recommends one specific action with rationale. Triggers on "/next", "what should I do", "what's next".
development2,871
pipeline
End-to-end source processing -- seed, reduce, process all claims through reflect/reweave/verify, archive. The full pipeline in one command. Triggers on "/pipeline", "/pipeline [file]", "process this end to end", "full pipeline".
testing2,871
tutorial
Interactive walkthrough for new users. Learn by doing — each step creates real content in your vault. Three tracks (researcher, manager, personal) with a universal learning arc. Triggers on "/tutorial", "walk me through", "how do I use this".
documentation2,871
ralph
Queue processing with fresh context per phase. Processes N tasks from the queue, spawning isolated subagents to prevent context contamination. Supports serial, parallel, batch filter, and dry run modes. Triggers on "/ralph", "/ralph N", "process queue", "run pipeline tasks".
devops2,871
refactor
Plan vault restructuring from config changes. Compares config.yaml against derivation.md, identifies dimension shifts, shows restructuring plan, executes on approval. Triggers on "/refactor", "restructure vault".
development2,871
stats
Show vault statistics and knowledge graph metrics. Provides a shareable snapshot of vault health, growth, and progress. Triggers on "/stats", "vault stats", "show metrics", "how big is my vault".
tools2,871
rethink
Challenge system assumptions against accumulated evidence. Triages observations and tensions, detects patterns, generates proposals. The scientific method applied to knowledge systems. Triggers on "/rethink", "review observations", "challenge assumptions", "what have I learned".
testing2,871
skills/plan-continue
--- tldr: Resume work on existing plan category: planning --- # /eidos:plan-continue Resume work on an existing plan file. ## Usage ``` /eidos:plan-continue [plan-name] ``` ## Instructions ### 1. Find Active Plans Search `memory/` for `plan - *.md` files. Identify incomplete plans by checking: - Actions without `[x]` completion markers (note: `[p]` postponed actions don't count as incomplete — a plan with only `[x]` and `[p]` actions may be effectively done) - Status field not `completed`
development51
skills/config
--- tldr: View and toggle eidos project settings category: utility --- # /eidos:config View and change project settings. ## Usage ``` /eidos:config /eidos:config <key> ``` ## Instructions ### 1. Check Config Read `.eidos-config.yaml` in the project root. - **File missing or incomplete** (missing keys): tell the user and offer to run `/eidos:init` to set up. If they accept, invoke `/eidos:init`. After init completes, continue to step 2. If they decline, stop — config can't be changed
tools51
skills/debug-session-start
--- tldr: Print session-start context verbatim for inspection category: utility --- # /eidos:debug-session-start Display the session-start context that was injected into this conversation. ## Usage ``` /eidos:debug-session-start ``` ## Instructions 1. Run the session-start hook directly: `bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh all` - The hook dispatches per unit (`<kind> <name>`); `all` (also the no-arg default) emits every unit in injection order, exactly as the harness conc
tools51
skills/toclaude
--- tldr: Persist behaviour corrections to CLAUDE.md category: utility --- # /eidos:toclaude Update CLAUDE.md or specs to correct undesired behaviour. ## Usage ``` /eidos:toclaude [description of correction] ``` ## Instructions 1. Understand the correction — what went wrong, what should happen instead 2. Identify the right location: - **`inject/core/*.md`** — plugin rules that apply to all eidos projects (pick the matching section file) - **`inject/feature/*.md`** — rules tied to a c
tools51
skills/init
--- tldr: Bootstrap eidos folder structure for a new project category: utility --- # /eidos:init Bootstrap the eidos folder structure in the current project. ## Usage ``` /eidos:init ``` ## Instructions ### 1. Check and Create Folders Create each target, reporting what was created vs what already existed: | Target | Purpose | |--------|---------| | `eidos/` | Spec root — what the system should be | | `memory/` | Procedural artifacts — how we got here | For each: - **Missing:** create th
tools51
skills/ping
--- tldr: Surface session status to the human via a native OS notification category: utility --- # /eidos:ping Send a short out-of-band signal to the human — "I'm done", "I have a question", "I hit a wall" — as a native OS notification. The agent picks the moment; the human gets a popup without watching the terminal. ## Setup (macOS, opt-in) This skill is a no-op until the human has installed the **eidos-ping** menubar app and pointed at it in `.eidos-config.yaml`: ```yaml ping_macos: /path
tools51
skills/compact
--- tldr: Pre-compact readiness check — verify nothing is lost before clearing session category: utility --- # /eidos:compact Readiness check before compacting or clearing a session. Not a wrap-up — a pre-flight check that confirms it's safe to let go of current context. ## Usage ``` /eidos:compact ``` ## Instructions ### 1. Check Git Status Run `git status`. Flag: - Uncommitted changes (staged or unstaged) - Untracked files in `eidos/` or `memory/` that might be lost If clean, note it a
tools51
skills/video
--- tldr: Generate a manim explainer video through staged research → outline → scenes → code → render → merge, with the outline doubling as a plan/state document category: utility --- # /eidos:video Turn a topic (or a folder of wiki-linked md) into a rendered manim video through a fixed pipeline. Pauses after each stage for review by default. Outline doubles as the plan/state document — wiki-linked checklist tracks progress. Full design in [[spec - video skill - outline driven manim pipeline
tools51
skills/plan
--- tldr: Create persistent plan for multi-step work category: planning --- # /eidos:plan Create a persistent plan file for multi-step work. ## Usage ``` /eidos:plan [brief description] ``` ## Instructions ### 1. Gather Context If the target file already exists with `status: seed`, read it — its content is raw context that seeds the plan. Use the seed's notes, links, and brain dumps to draft phases and actions. Skip clarification questions the seed already covers. Search for related arti
development51
skills/process
--- tldr: Work through a structured document point by point, resolving each item category: planning --- # /eidos:process Work through a structured document (coherence report, drift analysis, or any file with numbered findings) item by item — reading context, asking questions, making changes, and updating the source document with resolutions. Like `/eidos:plan-continue` but for any document with actionable items, not just plans. ## Usage ``` /eidos:process [file path or wiki link] ``` ## In
development38
skills/options
--- tldr: Present structured options using numbered lists category: utility --- # /eidos:options Present choices for user decision. ## Usage ``` /eidos:options [context] ``` ## Instructions 1. Analyse the situation — what are the distinct options? 2. For each option, identify trade-offs and implications 3. Present using [[spec - numbered lists - structured selectable output]] format: ``` 1 - Option A - Trade-off: ... - Implication: ... 2 - Option B - Trade-off: ... - Implication:
tools38
skills/observe
--- tldr: Capture testing observations mid-plan — structure issues, update specs, inject tasks category: observation --- # /eidos:observe Capture what you see that doesn't match what you want. Used in-session during active plan work — typically after a phase completes and you test the result. Observations become structured plan entries, spec updates, and implementation tasks. ## Usage ``` /eidos:observe ``` Assumes an active plan is loaded in the current session. If no plan is active, ask w
development38
skills/mono
--- tldr: Register a working subdirectory focus in a monorepo category: utility --- # /eidos:mono Register which subdirectory you're actually working in when Claude Code opens at the repo root. Stored per-user outside the repo, injected automatically at session start. ## Usage ``` /eidos:mono set <path> # set focus to subdirectory /eidos:mono clear # remove focus for this repo /eidos:mono list # show all mappings /eidos:mono # show current mapping or usage `
tools38
skills/info
--- tldr: Request more context before proceeding category: utility --- # /eidos:info Gather context before proceeding. ## Usage ``` /eidos:info [topic] ``` ## Instructions 1. Search for relevant context: - Specs in `eidos/` related to the topic - Memory files (plans, decisions, research) related to the topic - Codebase patterns if the topic is implementation-related 2. Present what was found 3. Identify gaps — what's still unclear 4. Ask the user targeted questions to fill gaps 5.
tools38
skills/goodjob
--- tldr: Capture positive calibration with context category: utility --- # /eidos:goodjob Capture a moment of good AI output with context, so future sessions can calibrate on what works. ## Usage ``` /eidos:goodjob [description of what was good] ``` ## Instructions ### 1. Understand the Moment Identify what was good — could be: - A well-chosen framing or metaphor - A structural insight or distinction - Good taste in a design decision - An approach that clicked - Anything the human found
tools38
skills/faildetect
--- tldr: Toggleable execution mode — dry-run, verify, run, verify-or-rollback category: utility --- # /eidos:faildetect Wraps script and command execution in a verify-or-rollback loop. When active, every non-trivial bash execution follows: dry-run → verify → run → verify-or-rollback. ## Usage ``` /eidos:faildetect # enable for this session /eidos:faildetect off # disable for this session ``` ## Instructions ### 1. Route by Command Parse arguments: - No args or `o
tools38
skills/experiment
--- tldr: Log-based iterative exploration with emergent phases and intent/try/outcome steps category: planning --- # /eidos:experiment Iterative exploration where each step's outcome determines the next step's intent. For work where the shape isn't known upfront — UI design, prototyping, debugging, spikes. The log IS the artifact, mineable for specs and learnings after. ## Usage ``` /eidos:experiment [topic] # start a new experiment /eidos:experiment continue # resume an existing
development38
skills/decision
--- tldr: Record a significant decision with options, rationale, and consequences category: planning --- # /eidos:decision Record a decision worth preserving — one where alternatives were evaluated and the rationale matters for future context. ## Usage ``` /eidos:decision [topic or question] ``` ## Instructions ### 1. Clarify the Decision If the decision point is unclear or broad, use AskUserQuestion: - What exactly are we deciding? - What constraints matter? - Are there options already i
development38
skills/code-review
--- tldr: Review code for quality, security, and maintainability category: observation --- # /eidos:code-review General-purpose code review — independent of eidos specs. ## Usage ``` /eidos:code-review [scope] ``` Scope options: - `path/to/dir` — review specific directory - `path/to/file.ts` — review specific file - `recent` — review files changed in recent commits - No argument — ask what to review ## Instructions ### 1. Determine Scope - Specific files/directories: review those - `rece
development38
skills/annotate
--- tldr: Leave inline AI feedback in files for human review category: core --- # /eidos:annotate Leave `{{AI ...}}` annotations inline in files — observations, questions, and suggestions for the human to review. ## Usage ``` /eidos:annotate [file ...] # annotate specific file(s) /eidos:annotate [file ...] --focus <type> # constrain annotation focus ``` Focus types: `coherence`, `clarity`, `gaps`, `stale` ## Instructions ### 1. Identify Targets - **File args** → use th
development38
skills/drift
--- tldr: Analyse divergence between eidos specs and code category: core --- # /eidos:drift Read-only analysis of gaps between intent (specs) and implementation (code). Two modes: broad (project-wide inventory) or focused (deep per-file analysis). Drift is vertical: spec ↔ code. For same-level checks (spec vs spec, code vs code), use `/eidos:coherence`. ## Usage ``` /eidos:drift # broad: all specs vs all code /eidos:drift [file ...] # focused: specific files aga
development38
skills/gid
--- tldr: Compress text to GID notation or decompress GID back to full text category: utility --- # /eidos:gid Bidirectional translation between prose and GID (General Idea Distillation) notation. Two modes: **compress** (prose → GID) and **decompress** (GID → prose). ## Usage ``` /eidos:gid compress <source> # prose → GID /eidos:gid write <source> # alias for compress /eidos:gid decompress <source> # GID → prose /eidos:gid read <source> # alias for decompress ``` Source c
tools38
skills/help
--- tldr: List all eidos skills with descriptions category: core --- # /eidos:help List available eidos commands, explain the workflow, and offer interactive guidance. ## Usage ``` /eidos:help ``` ## Instructions ### 1. List Skills Read all SKILL.md files in `${CLAUDE_PLUGIN_ROOT}/skills/`. For each, extract `tldr` and `category` from YAML frontmatter. Group by `category` in this order: core, planning, observation, utility. Present as a formatted list: ``` Eidos — spec-driven developmen
tools38
skills/next
--- tldr: Show actionable items to work on category: observation --- # /eidos:next Aggregate actionable items into a prioritised list. ## Usage ``` /eidos:next ``` ## Instructions ### 1. Scan Sources (fast) Use grep/glob to quickly filter without reading full files. Only read a file when you need detail for presentation. ```bash # Active plans with unchecked actions grep -rl '\[ \]' memory/plan\ -\ *.md 2>/dev/null # Open todos (existence = open) ls memory/todo\ -\ *.md 2>/dev/null # U
development38
skills/plan-review
--- tldr: Pre-implementation review of a plan — write findings to a file as a feedback surface category: planning --- # /eidos:plan-review Review a plan before implementation and write structured findings to a file with human feedback placeholders. ## Usage ``` /eidos:plan-review [plan-name] ``` ## Instructions ### 1. Find the Plan - **Arg given** → find the matching plan in `memory/` - **No arg** → search `memory/` for `plan - *.md` files, identify incomplete ones (same logic as `/eidos:
development38
skills/push
--- tldr: Implement or update code to match eidos spec category: core --- # /eidos:push Implement or update code to match what the spec describes (Platonic direction: spec → code). ## Usage ``` /eidos:push [spec ...] # push specific spec(s) to code /eidos:push recent [N] # push recently changed specs /eidos:push recursive [target] # force multi-pass mode: collect changes, then plan for subsections ``` ## Instructions ### 1. Identify Target Specs - **Spec paths** → us
development38
skills/research-recursive
--- tldr: Recursive research — each area becomes its own file, branching deeper via wiki-linked children category: observation --- # /eidos:research-recursive Recursive research on a broad topic where each area gets its own file. Areas can branch into sub-areas as nested wiki-linked research files, creating a navigable tree. ## Usage ``` /eidos:research-recursive [topic or domain] # start — will ask for budget /eidos:research-recursive [topic] budget 10 # st
development38
skills/status
--- tldr: Quick snapshot of active plan progress mid-session category: observation --- # /eidos:status Quick "where are we?" for the current session. Shows plan progress, recent commits, and what's next — without loading full context or creating files. ## Usage ``` /eidos:status ``` ## Instructions ### 1. Identify the Active Plan Find the plan being worked on this session. Check in order: 1. **Branch name** — if on `task/*`, grep `memory/` for a plan whose claim matches 2. **Recent commi
development38
skills/toeidos
--- tldr: Route insights into the spec system as new or adjusted specs and claims category: core --- # /eidos:toeidos Take semi-specified text and route it into eidos specs — as a new spec, a new claim, or an adjustment to an existing one. ## Usage ``` /eidos:toeidos [text describing an insight, observation, or requirement] ``` The input can be rough — stream of consciousness, bullet points, half-formed ideas, copy-pasted chat excerpts. ## Instructions ### 1. Parse the Input Extract the
development38
skills/wish
--- tldr: Capture feature requests that aren't yet specced category: utility --- # /eidos:wish Quickly capture a feature idea or request — something you want the system to do eventually, but that doesn't need a spec or plan yet. ## Usage ``` /eidos:wish [description] ``` ## Instructions 1. If no description provided, ask what the wish is 2. Run `date '+%y%m%d%H%M'` to get the current timestamp 3. Create `memory/wish - <timestamp> - <claim>.md`: ```markdown --- tldr: [description] --- # W
tools38
skills/clip
--- tldr: Copy relevant content to the system clipboard category: utility --- # /eidos:clip Copy something to the system clipboard so the user can paste it elsewhere. ## Usage ``` /eidos:clip [what to copy] ``` ## Instructions 1. Determine what to copy: - If the user specifies what (e.g. "clip that command", "clip the file path"), copy that. - If context makes it obvious (e.g. just generated a command, a snippet, a URL), copy the relevant thing. - If ambiguous, ask. 2. Detect the
tools38
skills/challenge
--- tldr: Constructive pushback on a proposal — surface blind spots, alternatives, and risks without being adversarial category: planning --- # /eidos:challenge Push back constructively on a proposal. Not adversarial — just honest feedback on what you might not have considered. ## Usage ``` /eidos:challenge [proposal or idea] ``` ## Instructions 1. Read the proposal carefully — understand what's being proposed and why 2. Assume the idea has merit — start from "this could work" not "this is
development38
skills/coherence
--- tldr: Check specs against each other for contradictions category: core --- # /eidos:coherence Detect contradictions, orphaned links, and missing cross-references across the spec graph. Drift checks spec vs code — coherence checks spec vs spec. ## Usage ``` /eidos:coherence ``` ## Instructions ### 1. Gather All Specs Read all `*.md` files in `eidos/`. For each, extract: - Claims from Behaviour sections (bullet points) - Wiki links (all `[[...]]` references) - Design patterns and archit
development38
skills/done
--- tldr: End session with export and merge offer category: utility --- # /eidos:done Structured session end. ## Usage ``` /eidos:done ``` ## Instructions ### 1. Export Conversation Run `/eidos:tomd` to create a session export in `memory/`. ### 2. Offer Reflection ``` Session exported: [[session - <timestamp> - <claim>]] Reflect on this session? (extracts learnings, tasks, incoherences) ``` If yes, run `/eidos:reflect` on the export. ### 3. Update Active Plan If there's an active pl
tools38
skills/pickmeup
--- tldr: Resurface recent activity to re-enter a project after time away category: observation --- # /eidos:pickmeup Re-entry point after days away — surface what happened, what's open, and where you left off. ## Usage ``` /eidos:pickmeup [days] ``` - `days` — how many days back to look (default: 3) ## Instructions ### 1. Determine Window Parse the optional `days` argument (default 3). Calculate the start date. ### 2. Gather Git Activity ```bash # Commits in the window, grouped by dat
development38
skills/pull
--- tldr: Reverse-engineer eidos spec from existing code category: core --- # /eidos:pull Extract the implicit spec from existing code into eidos spec files (Aristotelian direction: code → spec). ## Usage ``` /eidos:pull [file ...] # pull spec from specific files /eidos:pull recent [N] # pull from recently changed code files /eidos:pull plan [plan-name] # pull from files changed during a plan /eidos:pull recursive [target] # force multi-pass mode: overview first, th
development38
skills/reflect
--- tldr: Extract learnings from session or file category: observation --- # /eidos:reflect Extract learnings, tasks, and incoherences from a file. ## Usage ``` /eidos:reflect [file] ``` ## Instructions ### 1. Read the Source Read the target file (session export, research, or any file with insights to extract). ### 2. Identify Extractables Categorise findings: - **Learnings** — insights worth preserving (`learning -` prefix) - **Tasks** — things that need doing (`todo -` prefix) - **Inc
development38
skills/refine
--- tldr: Process inline comments in specs via structured dialogue category: core --- # /eidos:refine Process `{{comments}}` and `{{AI ...}}` annotations in eidos spec files through structured Q&A, then update the spec with resolved outcomes. ## Usage ``` /eidos:refine [file ...] # refine specific file(s) — creates refinement file /eidos:refine # find files with open comments automatically /eidos:refine inline [file ...] # resolve comments directly in the spec, no
development38
skills/spec
--- tldr: Think through and create a spec via structured Q&A category: core --- # /eidos:spec Think through a spec collaboratively before writing it. Asks questions to clarify target, behaviour, and design, then produces the spec file. ## Usage ``` /eidos:spec [topic or name] ``` ## Instructions ### 1. Gather Context If the target file already exists with `status: seed`, read it — its content is raw context that seeds the Q&A. Use the seed's notes, links, and brain dumps as pre-answered c
development38
skills/sync
--- tldr: Bidirectional reconciliation of specs and code category: core --- # /eidos:sync Reconcile specs and code bidirectionally — combines drift analysis with push and pull resolution. ## Usage ``` /eidos:sync # sync all specs vs all code /eidos:sync [file or spec ...] # sync specific files/specs /eidos:sync recent [N] # sync recently changed files ``` ## Instructions ### 1. Run Drift Run the drift analysis (same as `/eidos:drift` with matching args) to
development38
skills/tomd
--- tldr: Export conversation to markdown category: utility --- # /eidos:tomd Export the current conversation to markdown. ## Usage ``` /eidos:tomd [optional claim] ``` ## Instructions 1. If no claim provided, derive one from the session's main topic 2. Run `date '+%y%m%d%H%M'` to get the current timestamp. 3. Create `memory/session - <timestamp> - <claim>.md` (per [[spec - naming - prefixes structure filenames as prefix claim pairs]], e.g. `session - 2602141030 - auth implementation sessi
tools38
skills/true-name
--- tldr: Find precise domain names for vaguely referenced concepts category: core --- # /eidos:true-name Establish ubiquitous language — replace vague references with precise, canonical domain names and propagate everywhere. See [[c - ubiquitous language - shared vocabulary across specs code and conversation]]. When the same concept has three names, nobody is sure they're talking about the same thing. When it has one true name, communication becomes precise and specs become navigable. ## Us
development38
skills/weave
--- tldr: Discover missing wiki links between specs and prune broken or stale ones category: core --- # /eidos:weave Maintain the wiki-link graph — discover links that should exist and prune ones that shouldn't. Drift checks spec vs code. Coherence checks spec vs spec semantics. Weave checks spec vs spec structure (the links themselves). ## Usage ``` /eidos:weave # weave mode: discover missing links /eidos:weave prune # prune mode: find broken/stale/redundan
development38
skills/worktree
--- tldr: Create, list, and complete git worktrees for parallel task work category: utility --- # /eidos:worktree Manage git worktrees for parallel task work. Each worktree is a sibling directory with its own `task/` branch. ## Usage ``` /eidos:worktree <task> # create a new worktree /eidos:worktree list # list all worktrees /eidos:worktree complete [<task>] # merge and remove a worktree ``` ## Instructions ### 1. Determine Context ```bash repo_root=$(git wor
tools38
skills/meta
--- tldr: Analyse eidos skill output for quality, abstraction level, and coherence category: observation --- # /eidos:meta Analyse the output of an eidos skill and drive a structured feedback loop to surface quality issues, abstraction-level problems, and improvement directions. ## Usage ``` /eidos:meta [file or paste] # analyse specific output /eidos:meta # look for recent skill output in conversation ``` ## Instructions ### 1. Identify the Output - **File arg**
development38
skills/todo
--- tldr: Create todo files quickly category: utility --- # /eidos:todo Quickly capture a task. ## Usage ``` /eidos:todo [description] ``` ## Instructions 1. If no description provided, ask what needs doing 2. Run `date '+%y%m%d%H%M'` to get the current timestamp. 3. Create `memory/todo - <timestamp> - <claim>.md` (per [[spec - naming - prefixes structure filenames as prefix claim pairs]], e.g. `todo - 2602101400 - audit error handling consistency.md`): ```markdown --- tldr: [description]
tools38
skills/image
--- tldr: Persist an image with a markdown companion that captures its essence category: utility --- # /eidos:image Persist a dropped image with a markdown file that describes what the image shows. ## Usage ``` /eidos:image ``` User drops an image into chat (or has just dropped one). ## Instructions 1. **Look at the image.** Understand what it shows — a UI, a diagram, a sketch, an error, a photo, whatever it is. 2. Run `date '+%y%m%d%H%M'` to get the current timestamp. 3. Derive a short c
tools38
skills/claim
--- tldr: Extract and persist a claim from conversation context category: core --- # /eidos:claim Capture a specific learning, principle, or convention as a claim file. Claims are lightweight — a name, a sentence, and enough prose to be self-sufficient. ## Usage ``` /eidos:claim [topic or insight] ``` ## Instructions ### 1. Identify the Claim If the user gave a topic, use it. If not, look at recent conversation — what was clarified, decided, or learned? Ask only if the claim isn't clear f
development38
skills/brainstorm
--- tldr: Brainstorm ideas around a topic and capture them in a structured file category: planning --- # /eidos:brainstorm Generate and structure ideas around a topic. Starts broad, then clusters and selects standouts. ## Usage ``` /eidos:brainstorm [topic or question] ``` ## Instructions ### 1. Orient If the topic is broad or vague, use AskUserQuestion to focus: - What are we brainstorming about? - Any constraints or directions to favour? - What would a good outcome look like? If the to
development38
skills/architecture
--- tldr: Snapshot codebase structure for reference category: observation --- # /eidos:architecture Snapshot the current codebase structure and architectural patterns. Act as a **documentarian, not an evaluator** — document what exists without suggesting improvements. ## Usage ``` /eidos:architecture [scope] ``` Scope: directory path, module name, or "full" (default: full). ## Instructions ### 1. Gather Information For full snapshots, document each of these: **Git State** - Current bran
development38
skills/research-deep
--- tldr: Recursive deep research — outline areas, explore each progressively, synthesise across areas category: observation --- # /eidos:research-deep Deep research on a broad topic via recursive area exploration and progressive externalisation. ## Usage ``` /eidos:research-deep [topic or domain] # start — will ask for budget /eidos:research-deep [topic] budget 10 # start with soft budget of 10 /eidos:research-deep [topic] budget 10 hard # start
development38
skills/research
--- tldr: Research a topic and document findings with sources category: observation --- # /eidos:research Research a topic and produce a structured findings file. ## Usage ``` /eidos:research [topic or question] ``` ## Instructions ### 1. Clarify the Question If the target file already exists with `status: seed`, read it — its content is raw context that seeds the research. Use the seed's notes and links as starting sources, skip clarification the seed already covers. If the topic is bro
development38
skills/spiral
--- tldr: Stop spiraling and hand off to the user with actionable next steps category: utility --- # /eidos:spiral The user is telling you that you're spiraling — repeatedly trying things that aren't working, whether that's terminal commands, code fixes, or debugging attempts. ## Instructions 1. **Stop immediately.** Do not retry, try another variation, or make another speculative attempt. 2. **Summarise** what you were trying to do, what you tried, and what went wrong (briefly). 3. **Hand o
tools38
skills/reference
--- tldr: Capture or research external concepts the project relies on category: observation --- # /eidos:reference Curate external knowledge that the project depends on but doesn't own. ## Usage ``` /eidos:reference [concept or topic] ``` ## Instructions ### 1. Clarify the Concept If the topic is broad, use AskUserQuestion to narrow scope: - What specific concept or technology? - How does the project use it? - How deep should we go? If the concept is already clear, proceed. ### 2. Check
development38
skills/summary
--- tldr: Generate structured summary for file or session category: utility --- # /eidos:summary Summarise a file or session. ## Usage ``` /eidos:summary [file] ``` ## Instructions 1. Read the target file 2. Extract: key points, decisions made, artifacts created, open questions 3. Run `date '+%y%m%d%H%M'` to get the current timestamp. 4. Create `memory/summary - <timestamp> - <claim>.md` (per [[spec - naming - prefixes structure filenames as prefix claim pairs]], e.g. `summary - 2602141030
tools38
skills/tldr
--- tldr: Ultra-short summary of a topic, file, or set of files category: observation --- # /eidos:tldr Get the gist fast. Bullet-point summary — as short as possible without losing core ideas. ## Usage ``` /eidos:tldr [target] — default granularity (minimal) /eidos:tldr [target] detailed — more granularity, still concise ``` Target can be a file path, glob pattern, topic name, spec, or "this conversation". ## Instructions 1. Read the target (file, files, spec, or conversation)
development38
skills/toscript
--- tldr: Export code to script file category: utility --- # /eidos:toscript Extract code from conversation into script files. ## Usage ``` /eidos:toscript [filename] ``` ## Instructions 1. Scan conversation for code blocks 2. If multiple blocks with different languages, ask which to export 3. If filename provided, write there; otherwise suggest a sensible default 4. Commit immediately ## Output - Creates: script file at specified or suggested path
tools38
skills/toskill
--- tldr: Create new skill from conversation category: utility --- # /eidos:toskill Turn a discovered pattern into a reusable skill. ## Usage ``` /eidos:toskill [name] ``` ## Instructions 1. If no name provided, ask what the skill should do 2. Extract the pattern from conversation 3. Create `skills/<name>/<name>.md` with: - tldr in frontmatter - Skill heading with `# /eidos:<name>` - Usage section - Instructions section - Output section 4. Create `skills/<name>/SKILL.md` sym
tools38